当前位置：首页 > news >正文

java之多线程篇

news 来源：原创 2024/9/19 5:00:16

一、基本概念

1.什么是线程？

线程就是，操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。简单理解就是：应用软件中互相独立，可以同时运行的功能

2.什么是多线程？

有了多线程，我们就可以让程序同时做多件事情

3.多线程的作用？

提高效率

4.线程的应用场景？

只要你想让多个事情同时运行就需要用到多线程

比如：软件中的耗时操作、所有的聊天软件、所有的服务器

二、并发和并行的概念

1.什么是并发？

并发就是，同一时刻，有多个指令在单个CPU上交替执行。

2.什么是并行？

并行就是，同一时刻，有多个指令在多个CPU上同时执行

3.电脑不是只有一个CPU么，这个多个CPU同时执行的并行究竟是什么？

其实，CPU在市面有很多类型如下

比如2核4线程的CPU，就可以同时运行4个线程的任务。

三、多线程的实现方式（3种）

1.继承Thread类的方式进行实现

用法：

1.定义一个类继承Thread类

2.这个类重写run方法

3.在main方法里面创建定义的类的对象

4.通过该对象的.start()方法启动线程

示例代码
public class ThreadDemo1 {public static void main(String[] args) {MyThread myThread1 = new MyThread();MyThread myThread2 = new MyThread();myThread1.setName("线程1");myThread2.setName("线程2");myThread1.start();myThread2.start();}
}
class MyThread extends Thread{@Overridepublic void run(){for(int i=0;i<100;i++){System.out.println(Thread.currentThread().getName()+" "+i);}}
}
上面的两个线程的代码run方法是同时执行的，并不会等一个线程的循环走完。

注意：线程类开启后执行的是run方法的代码

2.实现Runnable接口的方式进行实现

用法：

1.自己定义一个类实现Runnable接口

2.重写里面的run方法

3.在main方法创建自己的类的对象

4.将定义的类传递给Thread构造方法创建一个Thread类的对象，并开启线程

示例

public class ThreadDemo2 {public static void main(String[] args) {MyThread myThread = new MyThread();Thread thread1 = new Thread(myThread);Thread thread2 = new Thread(myThread);thread1.setName("线程1");thread2.setName("线程2");thread2.start();thread1.start();}
}
class MyThread implements Runnable{@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println(Thread.currentThread().getName()+"-->"+i);}}
}

3.利用Callable接口和Future接口方式实现

前面两种实现方式，run方法没有返回值，不知道线程实现的结果，现在这个第三种方法是有返回值的。

用法：

1.创建一个类MyCallable实现callable接口

2.重写call（是有返回值的，表示多线程运行的结果）

3.创建MyCallable的对象（表示多线程要执行的任务）

4.传递MyCallable对象为参数创建FutureTask的对象（作用管理多线程运行的结果）

5.传递FutureTask对象为参数创建Thread类的对象，并启动（表示线程）

示例

public class ThreadDemo3 {public static void main(String[] args) throws ExecutionException, InterruptedException {MyCallable mc = new MyCallable();FutureTask<Integer> ft = new FutureTask<>(mc);Thread t = new Thread(ft);t.start();System.out.println(ft.get());}
}
class MyCallable implements Callable<Integer> {@Overridepublic Integer call() throws Exception {int sum = 0;for (int i = 0; i <= 100; i++) {sum += i;}return sum;}
}

结果输出5050

4.三种方式的比较

四、Thread类的常用成员方法

1.七个方法

2.前四个细节

String getName()

void setName(String name)

细节：

1. 果我们没有给线程设置名字，线程也是有默认的名字的

格式：Thread-X（X序号，从0开始的）

2.如果我们要给线程设置名字，可以用set方法进行设置，也可以构造方法设置

static Thread currentThread()

细节：

        当JVM虚拟机启动之后，会自动的启动多条线程

        其中有一条线程就叫做main线程

        他的作用就是去调用main方法，并执行里面的代码

        在以前，我们写的所有的代码，其实都是运行在main线程当中

static void sleep(long time)

细节：

1.哪条线程执行到这个方法，那么哪条线程就会在这里停留对应的时间

2.方法的参数：就表示睡眠的时间，单位毫秒

1秒 = 1000毫秒

3.时间到了之后，线程会自动的醒来，继续执行下面的其他代码

3.线程的优先级

（1）线程调度

抢占式调度：各条线程执行的顺序和时间是不确定的（随机）

非抢占式调度：各条线程执行的顺序是轮流执行和执行时间是差不多的

java中是选取第一种抢占式调度

（2）优先级（1~10）

抢占式调度就要涉及到线程的优先级越大，执行的顺序越前

于是可以通过Thread类的上面的两个成员方法来设置和获取线程的优先级

没有设置默认就是5

注意：这里的优先级是指优先级大的线程先执行的概率比较大，而不是百分百，比如说有两个一样的方法的线程，优先大的线程是有概率计较大的先执行完，但还是有小概率执行慢

4.守护线程

当一个线程使用Thread类的etDaemon(boolean on)时，这个线程变成守护线程。

细节：

这个线程也可以叫做“备胎”线程，它将其他线程视为“女神”线程，当其他线程结束的时候，这个守护线程就会陆续结束，觉得自己没必要存在了，这就会可能导致守护线程的代码没有全部执行完。

应用场景

上面聊天的场景，两个人聊天开两个线程，一个聊天，一个传输文件，如果聊天线程关闭了，就没有传输文件的必要了，于是将传输文件的线程设置为守护线程。

5.出让/礼让线程

在当前线程的工作不重要时，将CPU资源让位给其他线程，通过使用Thread类的yield()方法来将当前资源让位给其他同优先级线程
public static void main(String[] args) {Thread t1 = new Thread(() -> {System.out.println("线程1开始运行！");for (int i = 0; i < 50; i++) {if(i % 5 == 0) {System.out.println("让位！");Thread.yield();}System.out.println("1打印："+i);}System.out.println("线程1结束！");});Thread t2 = new Thread(() -> {System.out.println("线程2开始运行！");for (int i = 0; i < 50; i++) {System.out.println("2打印："+i);}});t1.start();t2.start();
}
观察结果，我们发现，在让位之后，尽可能多的在执行线程2的内容。

6.插入线程

当我们希望一个线程等待另一个线程执行完成后再继续进行，我们可以使用Thread类的join()方法来实现线程的插入。

public static void main(String[] args) {Thread t1 = new Thread(() -> {System.out.println("线程1开始运行！");for (int i = 0; i < 50; i++) {System.out.println("1打印："+i);}System.out.println("线程1结束！");});Thread t2 = new Thread(() -> {System.out.println("线程2开始运行！");for (int i = 0; i < 50; i++) {System.out.println("2打印："+i);if(i == 10){try {System.out.println("线程1加入到此线程！");t1.join();    //在i==10时，让线程1加入，先完成线程1的内容，再继续当前内容} catch (InterruptedException e) {e.printStackTrace();}}}});t1.start();t2.start();
}

线程2执行一半，线程1加入，先完成线程1的内容，再继续线程2的内容

五、线程的生命周期

六、线程的安全问题

1.售票代码引出问题

有100张票售卖，一共3个窗口在卖。

下面代码设置三个线程当作三个卖票的窗口，看看有什么问题

public class ThreadSafetyProblem {public static void main(String[] args) {MyThread1 myThread1 = new MyThread1();MyThread1 myThread2 = new MyThread1();MyThread1 myThread3 = new MyThread1();myThread1.setName("窗口1");myThread2.setName("窗口2");myThread3.setName("窗口3");myThread1.start();myThread2.start();myThread3.start();}
}
class MyThread1 extends Thread{//静态变量，几个线程共享private static int count = 0;public void run(){while(true){try {//这里只能try-catch丢给JVM，不能throwsThread.sleep(100);    //因为父类的run方法没有throws} catch (InterruptedException e) {throw new RuntimeException(e);}if (count < 100){System.out.println(Thread.currentThread().getName() + "正在卖第" + ++count+"张票");}else{break;}}}
}

2.超卖和重复卖问题

运行后出现的问题结果如下图：

三个窗口在同时卖一张票，不合法！

超卖了，仅有100张票

原因

线程的执行是有随机性的，cpu的执行权有可能被其他线程抢走。

线程1执行完票数的自增还没来得及打印的时候，线程2和线程3完成自增就会导致超卖和重复卖

那么要怎么解决这个安全问题呢？下一个点就会讲到解决的方法之一——同步代码块。

七、同步代码块

同步代码块的意思就是，把操作共享数据的代码锁起来

1.格式

synchronized(锁){

操作共享数据的代码

}

特点：

1.锁默认打开，有一个线程进去了，锁自动关闭

2.里面的代码全部执行完毕，线程出来，锁自动打开

2.修改后的售票代码

class MyThread1 extends Thread{//静态变量，几个线程共享private static int count = 0;//锁对象，一定要是唯一的static Object obj = new Object();public void run(){while(true){//同步代码块synchronized (obj){try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}if (count < 2000){System.out.println(Thread.currentThread().getName() + "正在卖第" + ++count+"张票");}else {break;}}}}
}

运行后的结果，票正常售卖，从第一张卖到最后一张。

3.细节问题

细节1：同步代码块不能放在while循环里面，因为放在外的话，一个线程拿到锁后就会必须把循环执行完，才会释放锁，这样的话一个线程就把票都卖完了。

细节2：锁的对象必须是唯一的，修改后的代码的锁是一个Object对象，用static修饰后表示全局共享唯一的对象。也可以使用MyThread.class表示唯一的字节码文件对象

八、同步方法

如果我们要锁的代码是整个方法，这个时候就要用到同步方法了

就是把synchronized关键字加到方法上

1.格式

修饰符 synchronized 返回值类型方法名（方法参数）{….}

2.特点

特点1：同步方法是锁住方法里面所有的代码

特点2：锁对象不能自己指定，如果方法是非静态的，锁对象就是方法所在类对象this

如果方法是静态的，锁对象就是当前类的字节码文件对象

3.使用同步方法解决售票问题

示例代码

这段代码与前面不同的是，这段代码是使用实现Runnable接口实现的多线程，只需要创建一个实现Runnable接口的javabean类的对象，所以票数这个变量的内存地址是唯一的，所以不用像上面的代码一样用static修饰票数count

注意：下面同步方法是非静态的，所以锁对象就是MyRunnable类的对象mr

public class ThreadSafetyProblem {public static void main(String[] args) {MyRunnable mr = new MyRunnable();Thread myThread1 = new Thread(mr);Thread myThread2 = new Thread(mr);Thread myThread3 = new Thread(mr);myThread1.setName("窗口1");myThread2.setName("窗口2");myThread3.setName("窗口3");myThread1.start();myThread2.start();myThread3.start();}
}
class MyRunnable implements Runnable{int count = 0;public void run(){while(true){//同步代码块if (method()) break;}}//锁对象是thisprivate synchronized boolean method() {try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}if (count < 2000){System.out.println(Thread.currentThread().getName() + "正在卖第" + ++count+"张票");}else {return true;}return false;}
}

4.StringBuffer为什么是线程安全的？

虽然StringBuilder和StringBuffer的成员方法是一样的，但为什么之前建议在多线程的情况下使用StringBuffer？

这是由于StringBuffer的成员方法比较 StringBuilder多了一个Sychronized修饰词，保证了线程的安全，但是在单线程的情况下，还是使用StringBuilder好一些。

九、Lock锁

1.售票代码使用手动上锁

public class ThreadSafetyProblem {public static void main(String[] args) {MyThread1 myThread1 = new MyThread1();MyThread1 myThread2 = new MyThread1();MyThread1 myThread3 = new MyThread1();myThread1.setName("窗口1");myThread2.setName("窗口2");myThread3.setName("窗口3");myThread1.start();myThread2.start();myThread3.start();}
}
class MyThread1 extends Thread{//静态变量，几个线程共享private static int count = 0;//创建一个锁对象 用static修饰表示共享唯一Lock lock = new ReentrantLock();public void run(){while(true){lock.lock();try {Thread.sleep(10);if (count < 2000){System.out.println(Thread.currentThread().getName() + "正在卖第" + ++count+"张票");}else {break;}} catch (InterruptedException e) {throw new RuntimeException(e);} finally {lock.unlock();}}}
}

十、死锁

1.示例代码

下面的代码用了锁的嵌套

public class MyThread extends Thread {static Object objA = new Object();static Object objB = new Object();@Overridepublic void run() {//1.循环while (true) {if ("线程1".equals(getName())) {synchronized (objA) {System.out.println("线程1拿到了A锁，准备拿B锁");//线程1卡在这里synchronized (objB) {System.out.println("线程1拿到了B锁，顺利执行完一轮");}}} else if ("线程2".equals(getName())) {if ("线程2".equals(getName())) {synchronized (objB) {System.out.println("线程2拿到了B锁，准备拿A锁");//线程2卡在这里synchronized (objA) {System.out.println("线程2拿到了A锁，顺利执行完一轮");}}}}}}
}

运行结果

显然两个线程都卡在第一层同步代码的锁那里，程序结束不了。

2.如何解决

很简单，不要写锁或同步代码块的锁嵌套就行。

十一、生产者和消费者模式

生产者消费者模式是一个十分经典的多线程协作的模式，就是要打破两个线程随机执行的规则，你一次我一次。

1.流程框图（等待唤醒机制）

2.涉及的方法

调用 wait() 方法的线程会释放它持有的锁，并进入等待状态，直到它被其他线程通过调用 notify() 或 notifyAll() 唤醒。

3.步骤

消费者和生产者的代码都按下面的步骤走：

1.循环

2.同步代码块(给消费者或生产者上锁)

3.判断共享数据是否到了末尾（到了末尾）

4.判断共享数据是否到了末尾（没有到末尾，执行（消费者或生产者的）核心逻辑）

4. 示例代码

(1)桌子代码

public class Desk {/*桌子的作用：控制生产者和消费者的执行*/// 判断桌子上有没有食物// 0 没有食物 生产者的线程执行// 1 有食物   消费者的线程执行//这里一般不用boolean类型，因为boolean类型只能是true或者false//如果有多条线程，int 可以表示多条线程的状态public static int foodFlat = 0;// 消费者现在所能吃食物的碗数public static int count = 10;//锁对象static Object lock = new Object();
}

(2)消费者代码

public class Foodie extends Thread {/*1.循环2.同步代码块(给消费者或生产者上锁)3.判断共享数据是否到了末尾（到了末尾）4.判断共享数据是否到了末尾（没有到末尾，执行（消费者或生产者的）核心逻辑）*/public void run(){while(true){synchronized (Desk.lock){if (Desk.count == 0){//吃不下了，直接结束break;}else {//如果桌上没有食物if (Desk.foodFlat == 0){try {//进入等待Desk.lock.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}else {//桌上有食物Desk.foodFlat = 0;Desk.count--;System.out.println("消费者吃掉了一碗面条，还能吃"+Desk.count+"碗");//通知唤醒厨师Desk.lock.notify();}}}}}
}

(3)生产者代码

public class Cook extends Thread {public void run(){while(true){synchronized (Desk.lock){//判断消费者是否吃饱了if (Desk.count==0){//吃饱了就结束break;}else {//消费者还能吃//判断桌子上还有食物么//有食物就进入等待if (Desk.foodFlat==1){try {Desk.lock.wait();} catch (InterruptedException e) {throw new RuntimeException(e);}}else {//没食物//厨师做一碗面条Desk.foodFlat = 1;System.out.println("厨师做了一碗面条");//做好就唤醒消费者Desk.lock.notify();}}}}}}

(4)main方法

public class Test {public static void main(String[] args) {Desk desk = new Desk();Foodie foodie = new Foodie();Cook cook = new Cook();foodie.setName("吃货");cook.setName("厨师");foodie.start();cook.start();}
}

(5)执行结果

从运行结果可以看出来，消费者和生产者模式可以使多个线程不再随机而是按顺序的来执行。

5.阻塞队列实现唤醒机制

(1)成员方法put和take

put方法底层原理

放入一个数据，put方法接收数据，先使当前线程获得锁（这个队列的），唤醒等待的线程，如果队列满了，当前线程进入等待，释放当前锁。

take方法底层原理

take方法取出数据，先使当前线程获得锁（这个队列的），唤醒等待的线程，如果队列空的，当前线程进入等待，释放当前锁。

(2)代码实现

用阻塞队列实现消费者和生产者的示例代码

消费者代码

public class Foodie extends Thread {ArrayBlockingQueue<String> queue;public Foodie(ArrayBlockingQueue<String> queue){this.queue = queue;}public void run() {while(true){try {queue.take();} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("吃货吃了一碗面条");}}
}

生产者代码

public class Cook extends Thread{ArrayBlockingQueue<String> queue;public Cook(ArrayBlockingQueue<String> queue) {this.queue = queue;}public void run() {while(true){try {queue.put("一碗面");} catch (InterruptedException e) {throw new RuntimeException(e);}System.out.println("厨师做了一碗面条");}}
}

main方法

public class Test {public static void main(String[] args) {ArrayBlockingQueue<String> queue = new ArrayBlockingQueue<>(1);Foodie f = new Foodie(queue);Cook c = new Cook(queue);f.setName("吃货");c.setName("厨师");f.start();c.start();}
}

运行结果

看到上面的结果有人会认为，厨师连续做了两碗面，是不是违反了模式了？

其实不然，消费者和生产者两条线程还是一条一次轮流执行的，重复输出是因为输出的代码放在了锁的外面，所以两个线程是随机的，抢着输出的，厨师做了多少碗面和消费者吃了多少碗的数量还是一样的。厨师放一碗面到队列，吃货就拿一碗。

注意：锁只在阻塞队列里面，即示例代码的put和take方法里面

十二、线程的6种状态

严格的来说，线程有7种状态，但是线程在进入要运行阶段的时候，JVM直接将线程丢给操作系统，java就不管了。所以对于java来说，线程是有6种状态。如下，

十三、Demo

1.Demo1

有100份礼品，两人同时发送，当剩下的礼品品小于10份分的时候则不再送出

利用多线程模拟该过程并将线程的名字和礼物的剩余数量打印出来

public class MyRunnable implements Runnable{int count = 100;@Overridepublic void run() {while (true) {synchronized (this) {if (count < 10){break;}else {count--;System.out.println(Thread.currentThread().getName() + "送出一份礼物，剩余" + count + "份礼物");}}}}
}
public class Test {public static void main(String[] args) {MyRunnable mr = new MyRunnable();Thread t1 = new Thread(mr);Thread t2 = new Thread(mr);t1.setName("小明");t2.setName("小红");t1.start();t2.start();}
}

2.Demo2

public class MyRunnable implements Runnable{double money = 100;int count = 3;Random rnd = new Random();public void run(){synchronized (this) {if (count == 0){System.out.println(Thread.currentThread().getName()+"没抢到");}else if (count == 1){count--;System.out.println(Thread.currentThread().getName()+"抢到了"+money+"元");money = 0;}else {double get = (rnd.nextDouble()*money);System.out.println(Thread.currentThread().getName()+"抢到了"+get+"元");money = money - get;count--;}}}
}
public class Test {public static void main(String[] args) {MyRunnable mr = new MyRunnable();Thread t1 = new Thread(mr);Thread t2 = new Thread(mr);Thread t3 = new Thread(mr);Thread t4 = new Thread(mr);Thread t5 = new Thread(mr);t1.setName("玩家1");t2.setName("玩家2");t3.setName("玩家3");t4.setName("玩家4");t5.setName("玩家5");t1.start();t2.start();t3.start();t4.start();t5.start();}
}

3.Demo3

public class MyRunnable implements Runnable{//奖池ArrayList<Integer> list;public MyRunnable(ArrayList<Integer> list) {this.list = list;}@Overridepublic void run() {while (true){synchronized (this) {if (list.isEmpty()){break;}Collections.shuffle(list);System.out.println(Thread.currentThread().getName()+"又产生了一个"+list.get(0)+"元大奖");list.remove(0);}//在锁外面休眠一会，这样另外一个线程就先执行，输出会好看一点try {Thread.sleep(1000);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}
public class Test {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);MyRunnable mr = new MyRunnable(list);Thread t1 = new Thread(mr);Thread t2 = new Thread(mr);t1.setName("抽奖箱1");t2.setName("抽奖箱2");t1.start();t2.start();}
}

4.Demo4 （多线程统计并求最大值）

public class MyRunnable implements Runnable{//奖池ArrayList<Integer> list;public MyRunnable(ArrayList<Integer> list) {this.list = list;}@Overridepublic void run() {//定义一个集合，收集每一个抽奖箱每次中奖的金额ArrayList<Integer> moneys = new ArrayList<>();while (true){synchronized (this) {if (list.isEmpty()){Collections.sort(moneys);System.out.println("在此次抽奖过程中，"+Thread.currentThread().getName()+"总共产生了"+moneys.size()+"个奖项");String string = moneys.toString();System.out.println("\t分别为:"+string.substring(1,string.length()-1)+"最高奖项为"+moneys.get(moneys.size() - 1)+",总计额为"+moneys.stream().mapToInt(Integer::intValue).sum());break;}Collections.shuffle(list);moneys.add(list.get(0));list.remove(0);}try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}}}
}
public class Test {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);String name1 = "抽奖箱1";String name2 = "抽奖箱2";MyRunnable mr = new MyRunnable(list);Thread t1 = new Thread(mr);Thread t2 = new Thread(mr);t1.setName(name1);t2.setName(name2);t1.start();t2.start();}
}

5.Demo5（多线程之间的比较）

由于这里要多线程之间进行比较，所以必须要有返回值，run方法没有返回值，所以使用第三种方法实现多线程，即实现Callable接口和Future接口

public class MyCallable implements Callable<Integer> {//奖池ArrayList<Integer> list;public MyCallable(ArrayList<Integer> list) {this.list = list;}@Overridepublic Integer call(){//定义一个集合，收集每一个抽奖箱每次中奖的金额ArrayList<Integer> moneys = new ArrayList<>();while (true){synchronized (this) {if (list.isEmpty()){Collections.sort(moneys);System.out.println("在此次抽奖过程中，"+Thread.currentThread().getName()+"总共产生了"+moneys.size()+"个奖项");String string = moneys.toString();System.out.println("\t分别为:"+string.substring(1,string.length()-1)+"最高奖项为"+moneys.get(moneys.size() - 1)+",总计额为"+moneys.stream().mapToInt(Integer::intValue).sum());break;}Collections.shuffle(list);moneys.add(list.get(0));list.remove(0);}try {Thread.sleep(10);} catch (InterruptedException e) {throw new RuntimeException(e);}}return moneys.get(moneys.size() - 1);}
}
public class Test {public static void main(String[] args) throws ExecutionException, InterruptedException {ArrayList<Integer> list = new ArrayList<>();Collections.addAll(list,10,5,20,50,100,200,500,800,2,80,300,700);String name1 = "抽奖箱1";String name2 = "抽奖箱2";MyCallable mc = new MyCallable(list);FutureTask<Integer> ft1 = new FutureTask<>(mc);FutureTask<Integer> ft2 = new FutureTask<>(mc);Thread t1 = new Thread(ft1,name1);Thread t2 = new Thread(ft2,name2);t1.start();t2.start();if (ft1.get()>ft2.get()){System.out.println("在此次抽奖过程中,"+name1+"中产生了最大奖项，该奖项金额为"+ft1.get()+"元");}else {System.out.println("在此次抽奖过程中,"+name2+"中产生了最大奖项，该奖项金额为"+ft2.get()+"元");}}
}