一基本概念

①程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

②进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

如：运行中的QQ，运行中的MP3播放器

程序是静态的，进程是动态的

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

③线程(thread)，进程可进一步细化为线程，是一个程序内部的一条执行路径。

若一个进程同一时间并行执行多个线程，就是支持多线程的

线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小 一个进程中的多个线程共享相同的内存单元/内存地址空间。它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

④ 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。

⑤ 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

二使用多线程的优点

背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？

多线程程序的优点： 1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

2. 提高计算机系统CPU的利用率

3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改

Thread类的有关方法

void start(): 启动线程，并执行对象的run()方法

run(): 线程在被调度时执行的操作

String getName(): 返回线程的名称 void setName(String name):设置该线程名称

static Thread currentThread(): 返回当前线程。在Thread子类中就是this，通常用于主线程和Runnable实现类

static void yield()：线程让步

暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程；若队列中没有同优先级的线程，忽略此方法

join() ：当某个程序执行流中调用其他线程的 join() 方法时，调用线程将被阻塞，直到 join() 方法加入的 join 线程执行完为止；低优先级的线程也可以获得执行

static void sleep(long millis)：(指定时间:毫秒) 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程有机会被执行,时间到后重排队；抛出InterruptedException异常

stop(): 强制线程生命期结束，不推荐使用

boolean isAlive()：返回boolean，判断线程是否还活着

三线程创建的方式

1、方式一：继承Threa类

1) 定义子类继承Thread类。

2) 子类中重写Thread类中的run方法。

3) 创建Thread子类对象，即创建了线程对象。

4) 调用线程对象start方法：启动线程，调用run方法。

代码如下：

/*** @Description 三个窗口卖票问题，总票数为100张* @Created by Administrator* @Date 2021/7/7 19:04* 线程创建方式一:继承Thread类* 1、创建一个继承于Thread类的子类* 2、重写Thread类的run()方法--->将线程的执行操作声明在run()中* 3、创建Thread类的子类的对象* 4、通过此对象调用start()*/
public class ThreadTest1 {public static void main(String[] args) {//3、创建Thread类的子类的对象Window t1 = new Window();Window t2 = new Window();Window t3 = new Window();t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");//4、通过此对象调用start()t1.start();t2.start();t3.start();}
}//1、创建一个继承于Thread类的子类
class Window extends Thread {private static int ticket = 100;//2、重写Thread类的run()方法--->将线程的执行操作声明在run()中@Overridepublic void run() {while (true) {if (ticket > 0) {System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);ticket--;} else {break;}}}
}

2、方式二：实现Runnable接口

1) 定义子类，实现Runnable接口。

2) 子类中重写Runnable接口中的run方法。

3) 通过Thread类含参构造器创建线程对象。

4) 将Runnable接口的子类对象作为实际参数传递给Thread类的构造器中。

5) 调用Thread类的start方法：开启线程，调用Runnable子类接口的run方法。

代码如下：

/*** @Description 线程创建方式二：实现Runnable接口* @Created by Administrator* @Date 2021/7/7 19:24* 1、创建了一个实现实现Runnable接口的类* 2、实现类去实现Runnable中的抽象方法* 3、将此对象作为参数传递到Thread类的构造器中，创建Threa类的对象* 4、通过Thread类的对象调用start()*/
public class ThreadTest2 {public static void main(String[] args) {Window1 w = new Window1();Thread t1 = new Thread(w);Thread t2 = new Thread(w);Thread t3 = new Thread(w);t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");//4、通过此对象调用start()t1.start();t2.start();t3.start();}
}class Window1 implements Runnable {private int ticket = 100;@Overridepublic void run() {while (true) {if (ticket > 0) {System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);ticket--;} else {break;}}}
}

3、方式三：实现Callable接口

与使用Runnable相比， Callable功能更强大些

 相比run()方法，可以有返回值

 方法可以抛出异常

 支持泛型的返回值

 需要借助FutureTask类，比如获取返回结果

Future接口

 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。

 FutrueTask是Futrue接口的唯一的实现类

 FutureTask 同时实现了Runnable, Future接口。它既可以作为 Runnable被线程执行，又可以作为Future得到Callable的返回值

代码如下：

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;/*** @Description  遍历100以内的偶数，并求和* @Created by Administrator* @Date 2021/7/7 20:50* 方式三：实现Callable接口*/
public class ThreadNew {public static void main(String[] args) {//3、创建Callable实现类的对象NumThread n=new NumThread();//4、将此Callable接口的实现类对象作为参数传递到FutureTask，创建FutureTask的对象FutureTask futureTask = new FutureTask(n);//5、将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()new Thread(futureTask).start();try {  //get()返回值即为futureTask构造器参数实现Callable实现类重写call()的返回值Object sum = futureTask.get();System.out.println("总和为："+sum);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
}
//1、创建一个实现Callable的实现类
class NumThread implements Callable{
//2、实现call()方法，将此线程需要执行的操作声明在call（）中@Overridepublic Object call() throws Exception {int sum=0;for(int i=0;i<100;i++){if(i%2==0){System.out.println(i);sum+=i;}}return sum;}
}

4、方式四：使用线程池

① 背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

② 思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

③好处： 1）提高响应速度（减少了创建新线程的时间）

2）降低资源消耗（重复利用线程池中线程，不需要每次都创建）

④便于线程管理

 corePoolSize：核心池的大小

 maximumPoolSize：最大线程数

 keepAliveTime：线程没有任务时最多保持多长时间后会终止

JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors

 ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor

 void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行 Runnable

 <T>Future<T> submit(Callable<T> task)：执行任务，有返回值，一般又来执行 Callable

 void shutdown() ：关闭连接池

代码如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;/*** @Description 方式四 ：使用线程池* @Created by Administrator* @Date 2021/7/7 21:12*/
public class ThreadPol {public static void main(String[] args) {//1、提供指定线程数量的线程池ExecutorService service = Executors.newFixedThreadPool(10);//2、执行指定的线程的操作，需要提供实现Runnable接口或者Callable接口实现类的对象service.execute(new Number());//适合适用于Runnable
//        service.submit();//适合适用于Callable//3、关闭线程池service.shutdown();}
}class Number implements Runnable {@Overridepublic void run() {for (int i = 0; i < 100; i++) {if (i % 2 == 0) {System.out.println(i);}}}
}

四解决线程安全问题

1、方式一：采用同步代码块

synchronized (对象){

// 需要被同步的代码；

}

用实现继承Thread方式创建线程演示用同步代码块解决线程安全问题

public class ThreadTest2 {public static void main(String[] args) {MyThread t1 = new MyThread();MyThread t2 = new MyThread();MyThread t3 = new MyThread();t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");//4、通过此对象调用start()t1.start();t2.start();t3.start();}
}
class MyThread extends Thread{//票数也需要设置为static，保证唯一，多个线程都操作这一百张票private static int ticket = 100;//方式一：该对象必须是静态的，保证唯一private static Object obj=new Object();@Overridepublic void run() {while (true) {//此处也可以使用   synchronized (MyThread.class)  synchronized (obj) {    //同步代码块if (ticket > 0) {try {   //线程睡眠，也就是阻塞Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);ticket--;} else {break;}}}}
}

用实现Runnable接口创建线程演示用同步代码块解决线程安全问题

/*** @Description 通过同步代码块来解决实现Runnable接口的线程安全问题* @Created by Administrator* @Date 2021/7/7 19:50* 通过同步机制来解决线程安全问题*      方法一： 同步代码块*        synchronized(同步代码块){*            //需要同步的代码*        }*        说明：操作共享数据的代码，即为需要同步的代码块*        同步监视器：俗称 锁  任何一个类的对象都可以充当锁*            要求：多个线程必须共用一个锁*/
public class ThreadTest3 {public static void main(String[] args) {Window2 w2 = new Window2();Thread t1 = new Thread(w2);Thread t2 = new Thread(w2);Thread t3 = new Thread(w2);t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");//4、通过此对象调用start()t1.start();t2.start();t3.start();}
}
class Window2 implements Runnable {private int ticket = 100;Object obj=new Object();  //充当锁，如果是继承方式创建Thread时需要加上static保证多个窗口共享@Overridepublic void run() {while (true) {synchronized (obj) {    //同步代码块if (ticket > 0) {try {   //线程睡眠，也就是阻塞Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);ticket--;} else {break;}}}}
}

2、方式二：采用同步方法

synchronized还可以放在方法声明中，表示整个方法为同步方法。例如：

public synchronized void show (String name){

….

}

非静态的同步方法，同步监视器是：this

静态的同步方法，同步监视器是：当前类本身

用继承方式创建的线程解决线程安全问题

public class ThreadTest3 {public static void main(String[] args) {MyThread2 t1 = new MyThread2();MyThread2 t2 = new MyThread2();MyThread2 t3 = new MyThread2();t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");//4、通过此对象调用start()t1.start();t2.start();t3.start();}
}class MyThread2 extends Thread{private static int ticket = 100;@Overridepublic void run() {while (true) {show();}}//同步监视器：当前类本身private static synchronized void show() {if (ticket > 0) {try {   //线程睡眠，也就是阻塞Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);ticket--;}}
}

用实现Runnable接口方式创建的线程解决线程安全问题

/*** @Description 通过同步方法来解决实现Runnable接口的线程安全问题* @Created by Administrator* @Date 2021/7/7 20:12* 方式二 通过同步方法* 1、同步方法仍然涉及到同步监视器，只是不需要显示的声明* 2、非静态的同步方法，同步监视器this*    静态的同步方法，同步监视器是：当前类本身*/
public class ThreadTeat4 {public static void main(String[] args) {Window3 w3 = new Window3();Thread t1 = new Thread(w3);Thread t2 = new Thread(w3);Thread t3 = new Thread(w3);t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");//4、通过此对象调用start()t1.start();t2.start();t3.start();}
}class Window3 implements Runnable {private int ticket = 100;@Overridepublic void run() {while (true) {show();}}//同步监视器：thisprivate synchronized void show() { //如果是继承方式创建Thread时需要加上staticif (ticket > 0) {try {   //线程睡眠，也就是阻塞Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);ticket--;}}
}

3、方式三：采用Lock锁方式

class A{private final ReentrantLock lock = new ReenTrantLock();public void m(){lock.lock();try{//保证线程安全的代码;}finally{lock.unlock();}}}

实用例子如下

import java.util.concurrent.locks.ReentrantLock;/*** @Classname LockTets* @Description 解决线程安全方式三：Lock锁* @Date 2021/7/8 15:41* @Created by wangB*/
class Window implements Runnable{private int ticket=100;
//实例化ReentrantLockprivate ReentrantLock lock=new ReentrantLock();@Overridepublic void run() {while (true){try {//调用锁定方法lock.lock();if(ticket>0){try {Thread.sleep(100);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+"；售票 ，票号为："+ticket);ticket--;}else {break;}}finally {//调用解锁方法lock.unlock();}}}
}public class LockTets {public static void main(String[] args) {Window w = new Window();Thread t1=new Thread(w);Thread t2=new Thread(w);Thread t3=new Thread(w);t1.setName("窗口一");t2.setName("窗口二");t3.setName("窗口三");t1.start();t2.start();t3.start();}
}

五线程的生命周期

JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能

阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态

死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

六线程通信

下面附上一个线程通信的例子：两个线程共同输出一到一百

/*** @Description 线程通信例子* @Created by Administrator* @Date 2021/7/9 9:44*/
public class day11 {public static void main(String[] args) {Number n=new Number();Thread t1=new Thread(n);Thread t2=new Thread(n);t1.setName("线程1");t2.setName("线程2");t1.start();t2.start();}
}
class Number implements Runnable{
private int number=1;@Overridepublic void run() {while(true){synchronized (this) {//唤醒线程notify();//一旦执行此方法 ，就会唤醒被wait的一个线程，如果有多个线程被wait，就会唤醒优先级高的if(number<=100){try {Thread.sleep(10);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName()+" :"+number);number++;//使得调用如下方法的线程进入阻塞状态try {wait();//一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器} catch (InterruptedException e) {e.printStackTrace();}}else {break;}}}}
}

多线程的创建方式和解决线程安全问题相关推荐

4种解决线程安全问题的方式
前言线程安全问题,在做高并发的系统的时候,是程序员经常需要考虑的地方.怎么有效的防止线程安全问题,保证数据的准确性?怎么合理的最大化的利用系统资源等,这些问题都需要充分的理解并运行线程.当然关于多线 ...
如何解决线程安全问题？有几种方式？synchronized与lock有什么异同？
1.谈谈你对同步代码块中同步监视器和共享数据的理解以及各自要求? 同步监视器:俗称锁.①任何一个类的对象都可以充当:②多个线程共用同一把锁. 共享数据:多个线程共同操作的数据. 2.什么情况会产生线程 ...
使用同步机制解决线程安全问题
线程的生命周期: 什么情况会产生线程安全问题? 当多个线程同时共享同一个全局变量或静态变量,做写的操作时,可能会发生数据冲突问题,即产生线程安全问题.读的操作不会发生线程安全问题. 例子:上文中的卖票 ...
Java解决线程安全问题
文章目录背景 1. 线程安全问题 1.1 什么是线程安全? 1.2 产生的原因 1.3 实例(买票超卖问题) 1.4 如何确定是否存在线程安全问题? 2. 如何解决线程安全问题? 2.1 不可变(I ...
如何解决线程安全问题
如何解决线程安全问题怎么解决线程的安全问题呢? 基本上所有解决线程安全问题的方式都是采用"序列化临界资源访问"的方式,即在同一时刻只有一个线程操作临界资源,操作完了才能让其他线程 ...
什么是线程安全问题及怎么解决线程安全问题
1.什么是线程安全问题就是多线程环境中 , 且存在数据共享 , 一个线程访问的共享数据被其他线程修改了, 那么就发生了线程安全问题 , 整个访问过程中 , 无一共享的数据被其他线程修改了就是线 ...
【解决线程安全问题：通过Lock锁对象】
[解决线程安全问题:通过Lock锁对象] 参考文章: (1)[解决线程安全问题:通过Lock锁对象] (2)https://www.cnblogs.com/zuixinxian/p/9570409.h ...
java并发之如何解决线程安全问题
java并发之如何解决线程安全问题参考文章: (1)java并发之如何解决线程安全问题 (2)https://www.cnblogs.com/w2154/p/6637717.html 备忘一下.
Java多线程（4）--线程的同步解决线程安全问题
多线程出现安全问题问题的原因: 当多条语句在操作同一个线程共享数据时,一个线程对多条语句只执行了一部分,还没有执行完,另一个线程参与进来执行,导致共享数据的错误. 解决办法: 对多条操作共享数据的语 ...

多线程的创建方式和解决线程安全问题

一基本概念

二使用多线程的优点

Thread类的有关方法

三线程创建的方式

1、方式一：继承Threa类

2、方式二：实现Runnable接口

3、方式三：实现Callable接口

4、方式四：使用线程池

四解决线程安全问题

1、方式一：采用同步代码块

2、方式二：采用同步方法

3、方式三：采用Lock锁方式

五线程的生命周期

六线程通信

多线程的创建方式和解决线程安全问题相关推荐

最新文章

热门文章

多线程的创建方式和解决线程安全问题

一 基本概念

二 使用多线程的优点

Thread类的有关方法

三 线程创建的方式

1、方式一 ：继承Threa类

2、方式二：实现Runnable接口

3、方式三：实现Callable接口

4、方式四：使用线程池

四 解决线程安全问题

1、方式一：采用同步代码块

2、方式二：采用同步方法

3、方式三：采用Lock锁方式

五 线程的生命周期

六 线程通信

多线程的创建方式和解决线程安全问题相关推荐

最新文章

热门文章

一基本概念

二使用多线程的优点

三线程创建的方式

1、方式一：继承Threa类

四解决线程安全问题

五线程的生命周期

六线程通信