- 一、多线程概述
- 1.1、进程和线程的概念
- 1.2、线程创建的方法
- 1.3、线程的状态机
- 二、多线程实现
- 2.1、继承Thread类
- 2.2、实现Runnable接口
- 2.3、实现Callable接口
- 2.4、并发问题
- 2.5、补充Lambda表达式
- 三、线程状态转换
- 3.1、线程停止
- 3.2、线程休眠
- 3.3、线程礼让
- 3.4、线程加入
- 3.5、线程状态检测
- 3.6、线程优先级
- 3.7、守护线程
- 四、线程同步
- 4.1、线程同步的概念
- 4.2、Java线程同步方法
- 五、线程通信
- 2.1、线程通信的概念
- 2.2、管程法
- 2.3、信号量法
- 2.4、线程池法
一、多线程概述
1.1、进程和线程的概念
1.1.1、进程
- 进程是执行程序的一次执行过程，是一个动态的过程，是一个活动的实体，是系统资源分配的单位
- 一个应用程序的运行就可以被看做是一个进程
1.1.2、线程
- 线程，是运行中的实际的任务执行者，一般的，一个进程中包含了多个可以同时运行的线程
- 线程就是独立的执行路径，是cpu调度和执行的单位，是序执行流中最小执行单位，是进程中实际运行单位
- 多线程的调度由CPU决定，无法人为干预
- 在java中，一定存在着两个线程，一个是main方法，即主线程，一个是gc线程，用于jvm的垃圾回收
1.2、线程创建的方法
1.2.1、继承Thread类
1.2.2、重写Runnable接口
1.2.3、重写callable接口
1.3、线程的状态机
1.3.1、线程的状态
java中线程共有 五种状态
- 新建状态
- 就绪状态
- 阻塞状态
- 运行状态
- 死亡状态
1.3.2、线程的状态机
二、多线程实现
2.1、继承Thread类
用法上述内容讲到，直接上代码
2.1.1、Thread的基本用法
- 代码实现
package com.kuang.class1;
/**
* 1、继承Thread类来实现多线程的demo
*/
public class TestThreadDemo extends Thread {
// 继承Thread类
@Override
public void run() {
// 重写run方法
for (int i = 0; i < 20; i++) {
System.out.println("子线程--" + i);
}
}
public static void main(String[] args) {
// 创建子线程对象，并调用start方法开启子线程
new TestThreadDemo().start();
// 这是主线程代码
for (int i = 0; i < 20; i++) {
System.out.println("主线程--" + i);
}
}
}
2.1.2、多线程下载网图
- 需要用到common-io包
- 实现
WebDownLoader类，里面实现一个DownLoader()方法，主要用到FileUtils.copyURLToFile()方法，将URL资源转为图片，即实现下载 - 主类继承Thread类，
run()方法调用DownLoader()来实现多线程下载 -
main方法创建对象，调用
start()方法开启线程 -
代码实现
package com.kuang.class1;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
/**
* 使用多线程下载网络图片的demo
* 需要用到common-io.jar
*/
public class TestThreadToDownload extends Thread {
private final String url;
private final String name;
public TestThreadToDownload(String url, String name) {
this.url = url;
this.name = name;
}
@Override
public void run() {
// 调用下载器实现多线程下载
WebDownLoader downLoader = new WebDownLoader();
downLoader.DownLoader(url,name);
System.out.println("下载了文件名为 ：" + name);
}
public static void main(String[] args) {
// 创建多线程对象
TestThreadToDownload t1 = new TestThreadToDownload("https://img1.baidu.com/it/u=3726701668,178087506&fm=253&fmt=auto&app=138&f=JPEG?w=353&h=499","./src/com/kuang/class1/image/1.jpg");
TestThreadToDownload t2 = new TestThreadToDownload("https://img1.baidu.com/it/u=3726701668,178087506&fm=253&fmt=auto&app=138&f=JPEG?w=353&h=450","./src/com/kuang/class1/image/2.jpg");
TestThreadToDownload t3 = new TestThreadToDownload("https://img1.baidu.com/it/u=3726701668,178087506&fm=253&fmt=auto&app=138&f=JPEG?w=353&h=500","./src/com/kuang/class1/image/3.jpg");
// 开启线程
t1.start();
t2.start();
t3.start();
}
}
/**
* 下载器实现
*/
class WebDownLoader {
public void DownLoader(String url, String name) {
try{
// 主要用到该方法，将传入的URL下载成本地文件
FileUtils.copyURLToFile(new URL(url),new File(name));
}
catch(IOException e){
e.printStackTrace();
System.out.println("IO异常，DownLoader下载出问题");
}
}
}
2.2、实现Runnable接口
2.2.1、Runnable基本用法
- 实现
Runnable接口并且必须重写其中的run()方法 - Runnable创建多线程使用静态代理模式，首先必须创建实现了该接口的类的对象
- 然后将对象传入Thread的构造器，创建一个Thread对象
- 最后通过Thread类的对象调用
start()方法开启线程
Runnable接口实现多线程比较特殊，但最终都是通过Thread类来运行的；推荐使用Runnable接口而非Thread类，因为java只能单继承，但可以实现多个接口
- 代码实现
package com.kuang.class1;
/**
* 使用Runnable接口来实现多线程
*/
public class TestRunnableDemo implements Runnable {
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println("子线程--" +i);
}
}
public static void main(String[] args) {
// 静态代理模式
// 先创建实现了Runnable接口的对象
// 再将这个对象传入Thread的构造器，创建一个Thread类对象
// 最后调用start方法开启
new Thread(new TestRunnableDemo()).start();
// 主线程代码
for (int i = 0; i < 20; i++) {
System.out.println("主线程--" +i);
}
}
}
2.2.2、模拟龟兔赛跑
- 设置一个静态类变量
winner模拟胜出者 -
设置一个裁判方法，如果已经存在胜出者，则线程停止；如果步数大于等于100，将该线程名赋给
winner，否则线程继续循环 -
代码实现
package com.kuang.class1;
/**
* 多线程实现龟兔赛跑demo，
*/
public class TestRaceDemo implements Runnable {
public static String winner; // 获胜者变量
@Override
public void run() {
for (int i = 1; i 跑了" + i + "步");
// 兔子在中间开始休息
if (i % 45 == 0 && Thread.currentThread().getName().equals("兔子")) {
try {
Thread.sleep(300);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
// 模拟乌龟跑的慢
if(Thread.currentThread().getName().equals("乌龟")) {
try {
Thread.sleep(5);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
// 裁判方法
public boolean gameOver(int steps) {
if(winner != null) {
return true;
}
if (steps >= 100) {
winner = Thread.currentThread().getName();
System.out.println("胜出者是" + winner);
return true;
}
return false;
}
public static void main(String[] args) {
TestRaceDemo raceDemo = new TestRaceDemo();
new Thread(raceDemo,"兔子").start();
new Thread(raceDemo,"乌龟").start();
}
}
2.3、实现Callable接口
- 实现
Callable接口，并且重写call()方法，该方法具有返回值，返回值类型同implements定义Callable<[返回值类型]><!--[返回值类型]-->时的类型
主方法开启多线程由两种方法：
方法1：分为创建服务、提交执行、获取结果、关闭服务四个固定步骤
- 第0步，先创建实现了Callable接口的类的对象
- 通过
ExecutorService service = Executors.newFixedThreadPool(<线程池容量>)<!--线程池容量-->创建一个自定义线程数的线程池，并开启服务 Future<[call方法返回类型]> r1 = service.submit(<第0步对象>)<!--第0步对象--><!--[call方法返回类型]-->将线程提交执行r1.get()获取线程执行完毕后的返回值service.shutdownNow()关闭服务
方法2：通过Thread代理模式开启线程
- 先创建实现了Callable接口的类的对象
FutureTask<string> task = new FutureTask<>(call)</string>创建FutureTask对象new Thread(task,"小明").start()开启线程
FutureTask泛型间接实现了 Runnable接口，相当于转换了一下
- 代码实现
package com.kuang.class1;
import java.util.concurrent.*;
/**
* 实现callable接口来创建多线程
*/
public class TestCallableDemo implements Callable {
boolean flag = false;
@Override
// 此处返回值与上方泛型一致
// 该方法相当于run方法，但带有返回值
public String call() {
if(!flag) {
for (int i = 1; i " + i);
}
}
return Thread.currentThread().getName() + "干完饭啦！";
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
// 创建目标对象
TestCallableDemo call = new TestCallableDemo();
// 创建服务，这里创建了一个容纳三个线程的线程池
ExecutorService service = Executors.newFixedThreadPool(3);
// 提交执行
Future r1 = service.submit(call);
Future r2 = service.submit(call);
Future r3 = service.submit(call);
System.out.println(r1.get());
System.out.println(r2.get());
System.out.println(r3.get());
service.shutdownNow();
// 第二种实现多线程的方法
/*FutureTask task = new FutureTask<>(call);
new Thread(task,"小明").start();*/
}
}
2.4、并发问题
在不控制并发的前提下实现买票系统，多线程进行买票，观察票的情况
- 创建票数的变量
- 实现
Runnable接口，在run()方法中模拟买票，每执行一次（买一张票），票就减少一张 -
主线程创建多个子线程来模拟并发
-
代码实现
package com.kuang.class1;
/**
* 多线程买票，不控制并发
*/
public class TestBuyTicketDemo implements Runnable {
private static int ticketNum = 10; // 票的数量
@Override
public void run() {
while (ticketNum > 0) {
// 模拟延时
try {
Thread.sleep(50);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// 买票程序
System.out.println(Thread.currentThread().getName() + "拿到了第" + ticketNum-- + "票");
}
}
public static void main(String[] args) {
TestBuyTicketDemo t = new TestBuyTicketDemo();
// 多线程买票
new Thread(t,"小明").start();
new Thread(t,"张三").start();
new Thread(t,"黄牛党").start();
}
}
- 效果展示 多次执行可能发现，不同人可能买到同一张票
- 问题发现 多个人买到了同一张票，导致 数据不唯一
2.5、补充Lambda表达式
2.5.1、Lambda的简介
- 为什么要用？
- 避免匿名内部类定义过多，可以让代码简洁紧凑，留下核心的逻辑
- Lambda表达式能够让程序员的编程更加高效
- 何时使用？
- 前提：必须存在一个函数式接口（即接口中只定义了一个抽象方法），这样我们就可以使用Lambda表达式来创建该接口的对象
- 语法格式
(parameters) -> expression[表达式][(parameters) -> statements[语句][(parameters) ->{ statements; }
2.5.2、Lambda表达式用法引入
将接口的实现类、静态内部类、局部内部类、匿名内部类、Lambda式进行对比，可以发现Lambda表达式异常简洁
- 代码实现
package com.kuang.class2;
/**
* lambda表达式的测试类
* 该表达式使用的前提是，有有函数型接口
*/
// 定义函数式接口：只存在一个抽象方法的接口
interface ILike {
void lambda();
}
public class TestLambda1 {
// 静态内部类实现接口
static class Like2 implements ILike {
@Override
public void lambda() {
System.out.println("静态内部类的lambda方法");
}
}
public static void main(String[] args) {
// 定义局部内部类
class Like3 implements ILike {
@Override
public void lambda() {
System.out.println("局部内部类的lambda方法");
}
}
// 定义匿名内部类
ILike like4 = new ILike() {
@Override
public void lambda() {
System.out.println("匿名内部类的lambda方法");
}
};
// lambda表达式写法
ILike like5 = () -> System.out.println("真正的lambda表达式");
new Like1().lambda();
new Like2().lambda();
new Like3().lambda();
like4.lambda();
like5.lambda();
}
}
// 定义接口实现类，传统用法
class Like1 implements ILike {
@Override
public void lambda() {
System.out.println("接口实现类的lambda方法");
}
}
- 效果展示 定义接口对象
like5，使用Lambda表达式，只关心核心逻辑的写法；使用时，直接通过该对象调用接口中的方法即可
2.5.3、Lambda深入理解
上面式函数式接口中的抽象方法无参数、无返回值，这里定义有参数及返回值的抽象方法；
详细请看Java Lambda 表达式 | 菜鸟教程 (runoob.com)
- 代码实现
package com.kuang.class2;
/**
* Lambda表达式测试2
* 接口方法有参数及返回值
*/
public class TestLambda2 {
public static void main(String[] args) {
// 这里使用lambda表达式，实现了接口中的抽象方法，将两数运算具体化，这里定义加法运算
MathOperation add = Integer::sum;
// 减法运算
MathOperation sub = (int a, int b) -> a - b;
// 乘法运算
MathOperation multi = (a,b) -> a * b;
System.out.println(add.operation(1,2));
System.out.println(sub.operation(3,5));
System.out.println(multi.operation(8,7));
}
// 定义函数式接口，
interface MathOperation {
// 将两数运算抽象出来
int operation(int a, int b);
}
}
三、线程状态转换
线程的五大状态在概述中已经讲到，这里主要讲解让线程状态转换的方法
3.1、线程停止
- 不推荐使用jdk中的内置方法，如
stop()，因为这是使线程强制停止的方法，可能会导致多线程的一些问题 -
推荐自定义标志位，并加上逻辑判断，让线程在某一条件下自动停止运行
-
代码实现
package com.kuang.class3;
/**
* 线程状态之：线程停止
* 建议使用标志位加条件判断，让线程自行停止
* 不建议使用jdk的内置方法，如stop()
*/
public class TestThreadStop implements Runnable {
@Override
public void run() {
int i = 0;
while (i != 15) { // 设置标志位，让线程主动停止
System.out.println("子线程---run" + i++);
}
System.out.println("子线程停止！！！");
}
public static void main(String[] args) {
new Thread(new TestThreadStop()).start();
for (int i = 0; i < 20; i++) {
System.out.println("main---run" + i);
}
}
}
3.2、线程休眠
- 主要用到
Sleep()方法让线程从运行状态转变为阻塞状态 -
每一个对象都有锁，
Sleep()不会释放锁 -
代码实现 实现循环显示当前时间的案例，一秒钟循环一次
package com.kuang.class3;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 线程休眠Sleep
*/
public class TestThreadSleep {
public static void main(String[] args) {
Date date = new Date(System.currentTimeMillis()); // 获得当前时间
while(true) {
try {
Thread.sleep(1000); // 一秒休眠一次
System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
date = new Date(System.currentTimeMillis()); // 更新时间
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
3.3、线程礼让
主要用到 yield()方法，在多线程情况下，让正处在运行态的线程转换为就绪态，重新竞争CPU调度（但是礼让不一定成功，再次调度还是看CPU心情）
- 代码实现
package com.kuang.class3;
/**
* 线程礼让的demo
*/
public class TestYield implements Runnable {
@Override
public void run() {
for (int i = 0; i < 10; i++) {
if (i % 2 == 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
Thread.yield(); // 线程礼让
}
System.out.println(Thread.currentThread().getName() + "线程执行" + i + "次");
}
System.out.println(Thread.currentThread().getName() + "线程运行结束");
}
public static void main(String[] args) {
TestYield yield = new TestYield();
new Thread(yield,"a").start();
new Thread(yield,"b").start();
}
}
3.4、线程加入
主要用到 jion()方法，线程加入相当于该线程插队，插队后该线程强制执行到结束，其他线程在此期间阻塞
- 代码实现
package com.kuang.class3;
/**
* 线程加入的案例，线程加入相当于让这个线程强制执行完，其他线程在此期间是阻塞的
*/
public class TestThreadJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println("VIP线程" + i);
}
}
public static void main(String[] args) throws InterruptedException {
TestThreadJoin join = new TestThreadJoin();
Thread thread = new Thread(join);
thread.start();
for (int i = 0; i < 10; i++) {
if(i == 5) {
thread.join(); // 线程插队，并且强制执行
}
System.out.println("main线程" + i);
}
}
}
3.5、线程状态检测
用到 Thread.State中的几个类变量，分别对应线程不同时期的状态
- 代码实现
package com.kuang.class3;
/**
* 观测线程状态
*/
public class TestThreadState {
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {
for (int i = 0; i < 5; i++) {
if (i % 2 == 0) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println("线程运行中。。。");
}
System.out.println("/////////");
});
Thread.State state = thread.getState();
System.out.println(state); // NEW状态
thread.start();
state = thread.getState();
System.out.println(state);
while(state != Thread.State.TERMINATED) {
state = thread.getState();
System.out.println(state);
Thread.sleep(500); // 每0.5s检测一次状态
}
}
}
3.6、线程优先级
- 线程的优先级从低到高分为了10个等级，分别对应数字1到10
- 一条线程可以使用
setPriority()方法自定义设置优先级，可以使用getPriority()查看优先级 -
高优先级并非优先调度，只是被调度的概率提高了，具体调度还是得看CPU
-
代码实现
package com.kuang.class3;
public class TestThreadPriority implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "的优先级是" + Thread.currentThread().getPriority());
}
public static void main(String[] args) {
TestThreadPriority test = new TestThreadPriority();
Thread t1 = new Thread(test,"t1");
Thread t2 = new Thread(test,"t2");
Thread t3 = new Thread(test,"t3");
Thread t4 = new Thread(test,"t4");
Thread t5 = new Thread(test,"t5");
// 线程自定义优先级
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t3.setPriority(8);
t4.setPriority(3);
t5.setPriority(Thread.NORM_PRIORITY); // 默认优先级
t1.start();
t2.start();
t3.start();
t4.start();
t5.start();
}
}
3.7、守护线程
- java提供了两种线程： 守护线程和 用户线程
- 守护线程，是指在程序运行时 在后台提供一种通用服务的线程，这种线程并不属于程序中不可或缺的部分
- 用户线程可以理解为被守护线程，JVM会等待所有用户线程，当用户线程执行完毕后，只剩守护线程存在，这时JVM会关闭，而不会等待守护线程再执行完毕，会杀死所有的守护线程（因为守护线程守护着用户线程，当用户线程执行完毕后，守护线程就无事可做了，当然没必要再往下继续执行了）
-
守护线程的优先级一般较低，用户可以使用
setDaemon()方法主动设置线程为守护线程 -
代码实现
package com.kuang.class3;
/**
* 主要测试守护线程的设置
*/
public class TestDaemon implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程启动");
// 这里延时是为了阻塞守护线程，让用户线程先执行完毕
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 这句话永远不会输出，因为被守护线程关闭后，jvm就关闭了，jvm不会等守护线程结束
System.out.println(Thread.currentThread().getName()+"线程关闭");
}
public static void main(String[] args){
System.out.println("main线程启动");
TestDaemon test = new TestDaemon();
Thread thread = new Thread(test,"A");
thread.setDaemon(true);
thread.start();
System.out.println("main线程关闭");
}
}
四、线程同步
第二节讲到不控制线程并发的一些问题，比如买票是抢到同一张票（ 数据不唯一），严重的可能会导致 死锁现象，即线程的永久等待；本节针对控制多线程并发的一系列问题，提出相应的解决方法。
4.1、线程同步的概念
- 线程不同步的后果 当多线程在 操作共享资源时，如果不控制线程的并发，就可能会导致共享区数据不唯一，或者线程间的死锁现象；尤其针对高并发环境下，比如12306买票，或者微信抢红包；如果不控制并发，很可能会出现比如有人在群里发了一个一百块红包，一百人同时开抢，可能这一百人都会抢到一百块钱，给平台造成损失。
- 何时需要线程同步 当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作，而其他线程又处于等待状态，实现线程同步的方法有很多，临界区对象（共享资源）就是其中一种
线程同步的底层涉及到一些算法问题，深入理解的话就需要学习《操作系统》
4.2、Java线程同步方法
4.2.1、同步方法或者同步块
主要学习 synchronized关键字的使用
①、synchronized修饰方法
使方法转变为同步方法，相当于给方法加锁；当方法中有线程正在操作，该方法就会被 加锁，其他线程就必须 排队；直到该线程操作完毕后主动 解锁，其他线程再竞争进入该方法；之后依旧进行加锁和解锁操作。
- 代码实现 重现抢票程序，观察使用
synchronized修饰前和修饰后，输出结果的变化
package com.kuang.class4.synchronizedDemo;
/**
* 不安全的买票案例，体验同步修饰符的用法
*/
public class UnsafeBuyTicket {
public static void main(String[] args) {
BuyTicket station = new BuyTicket();
new Thread(station,"小明").start();
new Thread(station,"黄牛党").start();
}
}
class BuyTicket implements Runnable {
private int ticketNum = 10; // 票的数量
boolean flag = true;
@Override
public void run() {
while(flag) {
try {
buy();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
// 此处将synchronized去掉再加上，观察输出变化
private synchronized void buy() throws InterruptedException {
if (ticketNum
给 buy()方法加锁，观察变化
②、synchronized同步块
- 用法：
synchronized(boj) {}
此处 obj称为同步监视器， obj可以是任何对象，但一般选用共享区资源作为监视器，例如上述买票程序中的票的数量 ticketNum就是共享区资源
- 代码实现 多线程操作不安全的泛型集合
ArrayList，观察加锁前后变化
package com.kuang.class4.synchronizedDemo;
import java.util.ArrayList;
import java.util.List;
/**
* 线程不安全的泛型集合，体验同步块的用法
*/
public class UnsafeList {
public static void main(String[] args) {
List list = new ArrayList<>();
for (int i = 0; i < 100000; i++) {
new Thread(() ->{
synchronized (list) {
list.add(Thread.currentThread().getName());}
}).start();
}
// 这里的sleep是为了让主线程休眠，否则主线程可能会提前输出list的size
try {
Thread.sleep(3000);
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(list.size());
}
}
多线程给 list添加1000000条数据，最后输出 list的大小
2. 前后对比 未使用同步块之前，缺少数据
4.2.2、Lock锁
取自JUC包下的锁机制，只能对代码块进行加锁，但效率比synchronized更高
①、一般写法
private final ReentrantLock lock = new ReentrantLock(); // 定义锁
public void run() {
try {
lock.lock();
// 这里写需要同步的代码块
}
finally {
lock.unlock(); // 如同步代码块有异常，则将解锁写在此处
// 但一般都在此处解锁
}
}
②、案例说明
继续以买票案例为例
- 代码实现
package com.kuang.class4.lockDemo;
import java.util.concurrent.locks.ReentrantLock;
/**
* 锁机制的测试案例
*/
public class TestLock {
public static void main(String[] args) {
BuyTicket2 ticket2 = new BuyTicket2();
new Thread(ticket2,"小明").start();
new Thread(ticket2,"小红").start();
new Thread(ticket2,"黄牛党").start();
}
}
class BuyTicket2 implements Runnable {
private int ticketNum = 10;
boolean flag = true;
private final ReentrantLock lock = new ReentrantLock(); // 定义可重入锁
@Override
public void run() {
while(flag) {
try {
buy();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
private void buy() throws InterruptedException {
try {
lock.lock(); // 在临界区加锁
if (ticketNum
五、线程通信
2.1、线程通信的概念
2.1.1、为什么需要线程通信
线程是操作系统调度的 最小单位，有自己的 栈空间，可以按照既定的代码逐步的执行，但是如果每个线程间都孤立的运行，那就会造资源浪费。所以在现实中，我们需要这些 线程间可以按照指定的规则 共同完成一件任务，所以这些线程之间就需要 互相协调，这个过程被称为 线程的通信
因此线程通信可以概括为：当多个线程共同操作共享的资源时，互相告知自己的状态以避免资源争夺，并且互相协调，完成同一件任务
2.1.2、线程的通信的方式
- 共享内存
- 管程
- 信号量
- 管道
- 其他
2.2、管程法
实现生产者、消费者模型，该模型大致定义如下：
- 存在 缓冲区，生产者在缓冲区放入东西，消费者从缓冲区取出东西进行消费
- 生产者，当缓冲区不满时，生产者就生产东西放入缓冲区；当缓冲区满时，生产者就停止生产进入阻塞，并通知消费者取出东西
-
消费者，当缓冲区存在东西时，就不断取出；当缓冲区为空时，消费者停止消费进入阻塞，并通知生产了生产东西
-
代码实现
package com.kuang.class5;
/**
* 测试生产者和消费者的案例
*/
public class TestProducerAndCustomer {
public static void main(String[] args) {
SynContainer container = new SynContainer();
new Producer(container).start(); // 启动生产者线程
new Customer(container).start(); // 启动消费者线程
}
}
// 生产者类
class Producer extends Thread {
SynContainer container;
public Producer(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 1; i < 101; i++) {
container.push(new Goods(i)); // 给缓冲区放入东西
System.out.println("生产了第" + i + "个商品");
}
}
}
class Customer extends Thread {
SynContainer container;
public Customer(SynContainer container) {
this.container = container;
}
@Override
public void run() {
for (int i = 1; i < 101; i++) {
System.out.println("消费了第" + container.pop().id + "个商品");
// 从缓冲区取出东西
}
}
}
// 商品类
class Goods {
int id; // 产品编号
public Goods(int id) {
this.id = id;
}
}
// 缓冲区类
class SynContainer {
Goods[] goods = new Goods[10]; // 定义一个容量为10的缓冲区
int count = 0; // 缓冲区商品计数器
// 放入缓冲区
public synchronized void push(Goods g) {
if (count == goods.length) {
// 缓冲区满了，生产者休息
try {
this.wait();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
goods[count] = g;
count++;
// 通知消费者消费
this.notifyAll();
}
// 从缓冲区取出
public synchronized Goods pop() {
if (count == 0) {
try {
// 缓冲区为空，消费者阻塞
this.wait();
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
count--;
// 通知生产者生产
this.notifyAll();
return goods[count];
}
}
2.3、信号量法
是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段 不被并发调用。在进入一个关键代码段之前，线程必须获取一个 信号量；一旦该关键代码段完成了，那么该线程必须 释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。
- 代码实现 代码实现生产者消费者模型的吃水果案例，妈妈往盘子中放水果，我从盘子中拿水果吃，盘子只有一个；当盘子中有水果，就不能再放了，并通知我吃水果；当盘子中没了水果，我就不能吃，并通知妈妈放水果。
package com.kuang.class5;
/**
* 吃水果的生产者消费者模型
* 妈妈往盘子放水果，我从盘子中取水果吃
*/
public class TestEatFruit {
public static void main(String[] args) {
Plate plate = new Plate();
new Me(plate).start();
new Mom(plate).start();
}
}
class Mom extends Thread {
Plate plate;
public Mom(Plate plate) {
this.plate = plate;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
if (i % 2 == 0) {
plate.put("苹果");
}
else if (i % 5 == 0) {
plate.put("香蕉");
}
else {
plate.put("橘子");
}
}
}
}
class Me extends Thread {
Plate plate;
public Me(Plate plate) {
this.plate = plate;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
plate.eat();
}
}
}
class Plate {
String fruitName; // 水果名
boolean mutex = true; // 定义互斥信号量
public synchronized void put(String name) {
if (!mutex) {
try {
this.wait(); // 当盘子中有水果就必须阻塞
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("妈咪给了一个" + name);
this.notifyAll(); // 放了一个水果，通知我吃水果
this.fruitName = name;
this.mutex = !mutex;
}
public synchronized void eat() {
if (mutex) {
try {
this.wait(); // 当盘子中没有水果，就阻塞
}
catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("我吃掉了一个" + fruitName);
this.notifyAll(); // 吃掉一个水果，通知放水果
this.mutex = !mutex;
}
}
}
- 效果展示 两两一组
2.4、线程池法
在高并发情况下，经常要进行线程的创建与销毁，对性能影响很大； 线程池法的思路就是提前创建好多个线程，放入线程池中，使用时直接获取，使用完后放入池中，可以必变重复的创建和销毁操作，提高服务器效率（可以类比共享单车，提前投放一批单车，使用时直接扫码用，使用完后放回单车点）
思路：
- 多线程实现类实现Runnable接口
- 主类使用
ExecutorService创建线程池 - 使用
execute(Runnable obj)执行任务，该方法属于上面接口，没有返回值 -
最后使用
shutdown()，关闭连接池 -
代码实现
package com.kuang.class5;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 使用线程池方法实现线程通信
*/
public class TestThreadPool {
public static void main(String[] args) {
// 创建线程池服务，参数为线程池大小
// 该部分内容属于JUC编程，Executors也属于JUC包
ExecutorService service = Executors.newFixedThreadPool(10);
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
service.shutdown();
}
}
class MyThread implements Runnable {
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
Original: https://www.cnblogs.com/70ny/p/16687435.html
Author: 70ny
Title: java多线程基础学习
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/643063/
转载文章受原作者版权保护。转载请注明原作者出处！