多线程

文章目录

多线程
- 核心概念
- - `Process`与`Thread`
- 线程三种创建方式
- - 继承`Thread`类
  - - 使用多线程实现下载网络图片
  - 实现`Runnable`接口
  - - 多线程同时操作同一个对象
    - 模拟龟兔赛跑(线程执行速度)
  - 实现`Callable`接口
- 静态代理
- `Lanmda`表达式
- - 简介
  - 作用：
  - 函数式接口`Functional Interface`
  - 定义
  - 示例：
  - - Lambda表达式简化：
  - 总结
- 线程状态
- - 创建
  - - 总结
  - 就绪
  - - 线程礼让
  - 运行
  - 阻塞
  - - 线程休眠`Sleep`
    - `Join`合并线程
  - 死亡
  - 线程状态观测
  - 线程优先级
  - 守护线（daemon）程
- 线程同步
- 死锁
- - 产生死锁的四个必要条件：
- Lock(锁)
- - `synchronized `与`Lock`的对比
- 线程并发协作模型：生产者消费者模式
- - 解决方法
  - - 管程法
    - 信号灯法
- 线程池
- - 背景:
  - 思路:
  - 好处:
  - 使用
  - 示例

核心概念

`Process`与`Thread`

一个进程对应一个应用程序，程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。也就是说你本地的项目代码在不运行它的时候它们就是一堆静态的文件，不运行它将不会起任何作用！
进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位
通常在一个进程中可以包含若干个线程，当然一个进程中至少有一个线程，不然没有存在的意义
- 线程是CPU调度和执行的的单位。
真正的多线程是指有多个CPU，即多核。如果是单核服务器，那么它所属的缩线程应用一定是模拟出来的，即在一个cpu的情况下，在同一个时间点，cpu只能执行一个代码，因为切换的很快，所以对于人类来说就有同时执行的错觉。
多进程的作用不是提高执行速度，而是提高CPU的使用率
进程和进程之间的内存是独立的
线程就是独立的执行路径;
在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程;
main()称之为主线程，为系统的入口，用于执行整个程序;
在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度，调度器是与操作系统紧密相关的，先后顺序是不能人为的干预的。
对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制;线程会带来额外的开销，如cpu调度时间，并发控制开销。
每个线程在自己的工作内存交互，内存控制不当会造成数据不一致
线程是一个进程中的执行场景。一个进程可以启动多个线程
多线程作用不是为了提高执行速度，而是提高应用程序的使用率
线程和线程共享“堆内存和方法区内存”，栈内存是独立的，一个线程一个栈
由于多线程在来回切换，所以给现实世界中的人类一种错觉：感觉多个线程在同时并发执行。

线程三种创建方式

继承`Thread`类

继承Thread类

重写Thread类的run()方法

创建线程对象，调用start()方法启动线程(如果是调用run()方法将使用单线程)

线程不一定是立即执行的，什么时候执行由CPU来调度安排

/**
* 1.继承用于操作线程的Thread类：extends Thread
*/
public class TestThread extends Thread {/*** 2.重写Tread的run()方法*/@Overridepublic void run() {// run方法线程体for (int i = 0; i < 18; i++) {System.out.println("你在吃屎！");}}/*** main线程----主线程*/public static void main(String[] args) {// 3.创建一个线程对象TestThread testThread = new TestThread();// 4.调用start()方法启动线程,使线程同时执行(多线程)，此时多个线程会随机的交替执行，这个随机是由CPU决定的testThread.start();// 单线程//testThread.run();单线程只会一条线走，先执行什么、再执行什么for (int i = 0; i < 999; i++) {System.out.println("你在蹦迪");}}
}

使用多线程实现下载网络图片

// 要导入commons.io这个包
import org.apache.commons.io.FileUtils;import java.io.File;
import java.io.IOException;
import java.net.URL;/*** @Description: 实现多线程同步下载图片(顺序有点乱，标注的顺序是思维也是程序行走正常所需的步骤)* @Author Djn* @Date 2020/11/13* @Since V1.0 add-->* @Version V1.0**/
// 1.继承Thread线程类
public class ThreadDownloaderPng extends Thread {/*** 4.声明对象的属性：地址与名称，以及本类的构造器*/// 图片存储地址private String url;// 图片存储名称private String name;// 构造器public ThreadDownloaderPng(String url, String name) {this.url = url;this.name = name;}// 5.重写Thread的run()方法  即创建要测试的多线程 线程体@Overridepublic void run() {PngDownloader pngDownloader = new PngDownloader();pngDownloader.downloader(url, name);System.out.println("下载了文件名为" + name);}// 6.创建主线程public static void main(String[] args) {// 7.使用上面的构造器创建对象  这里我依次下载了apaqi、docker以及Maven的logoThreadDownloaderPng t1 = new ThreadDownloaderPng("http://commons.apache.org/images/commons-logo.png", "阿帕奇的logo.jpg");ThreadDownloaderPng t2 = new ThreadDownloaderPng("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1605265343111&di=bb9215e6666b513c91a0a9e4284b5adf&imgtype=0&src=http%3A%2F%2F5b0988e595225.cdn.sohucs.com%2Fimages%2F20190608%2F94ffe7706df04db4ab2fc2de10697a68.jpeg", "Docker.jpg");ThreadDownloaderPng t3 = new ThreadDownloaderPng("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1605265313962&di=e8f6395d62c50c92d57502a0ebbe6f02&imgtype=0&src=http%3A%2F%2Fpic2.zhimg.com%2Fv2-94a00bfec307801902f81d81140a1c8a_1200x500.jpg", "Maven.jpg");// 8.启动线程  虽然写的启动顺序是1、2、3  但实际执行的时候这三条线程的顺序是随机的t1.start();t2.start();t3.start();}
}// 2.写一个下载器
class PngDownloader {// 3.下载方法  因为下载资源要定位资源的地址，所以url必不可少，name为下载下来后将这个文件命名成什么public void downloader(String url, String name) {try {// URL要抛出IO异常，可以try catch也可以直接抛出去FileUtils.copyURLToFile(new URL(url), new File(name));} catch (IOException e) {// 这里自定义输出了一下异常信息，方便定位问题System.out.println("发生了IO异常，PngDownloader方法出现了问题");}}
}

实现`Runnable`接口

启动线程方式：传入目标线程对象+Thread(对象).start()

// 1.实现Runnable接口
public class TestRunnable implements Runnable {// 2.重写run方法作为线程体@Overridepublic void run() {for (int i = 0; i < 20; i++) {System.out.println("++++++Runnable线程体！+++++++");}}// 3.主线程public static void main(String[] args) {// 4.创建runnable接口的实现类对象TestRunnable testRunnable = new TestRunnable();// 5.代理：创建一个线程对象用于调用start()方法开启线程// 将实现runnable接口的对象放入Thread里new Thread(testRunnable).start();for (int i = 0; i < 30; i++) {System.out.println("==========主线程============");}}
}

多线程同时操作同一个对象

// 实现多个线程操作同一资源，不过此时线程是不安全的，数据会紊乱(同一个资源被多个线程拿到)
// 1.实现Runnable接口
public class TestThread2 implements Runnable {private int ticketNums = 15;// 2.重写run方法 线程体@Overridepublic void run() {// 循环减ticketNumswhile (true) {// ticketNums小于1时停止循环if (ticketNums <= 0) {break;}// 因为CPU处理速度太快，模拟让线程延时一下try {Thread.sleep(200);} catch (InterruptedException e) {e.printStackTrace();}// Thread.currentThread()获取这个线程，.getName()获取线程名字System.out.println(Thread.currentThread().getName() + "--->拿到了第" + ticketNums-- + "票");}}// 主线程public static void main(String[] args) {TestThread2 t = new TestThread2();// 开启多线程new Thread(t, "a").start();new Thread(t, "b").start();new Thread(t, "c").start();new Thread(t, "d").start();}
}

模拟龟兔赛跑(线程执行速度)

准备

准备一个有固定距离的赛道
判断比赛是否结束
打印输出胜利者
龟兔赛跑开始
让兔子睡觉来实现乌龟跑赢兔子
让乌龟赢

    // 胜利者private static String winner;@Overridepublic void run() {for (int i = 0; i <= 100; i++) {// 模拟兔子休息       每20步休息50毫秒if (Thread.currentThread().getName().equals("兔子") && i % 20 == 0) {try {Thread.sleep(50);} catch (InterruptedException e) {e.printStackTrace();}}// 判断比赛是否结束boolean flag = gameOver(i);// 如果比赛结束了，就停止程序if (flag) {break;}System.out.println(Thread.currentThread().getName() + "-->跑了" + i + "步");}}// 判断比赛是否结束private boolean gameOver(int steps) {// 判断是否有胜利者if (winner != null) {return true;}else{if (steps == 100) {winner = Thread.currentThread().getName();System.out.println("Winner is :" + winner);return true;}}return false;}public static void main(String[] args) {Race race = new Race();new Thread(race, "兔子").start();new Thread(race, "乌龟").start();}
}

实现`Callable`接口

实现Callable接口，需要返回值的类型
重写call方法，需要抛出异常
创建目标对象
创建执行服务：ExecutorService ser = Executor.newFixedThreadPool(1);
提交执行：Future<Boolean> result1 = ser.submit(t1);
获取结果：boolean r1 = result1.get()
关闭服务：ser.shutdownNow();

/*** Callable的优点：* 1.可以定义返回值* 2.可以抛出异常**/// 1.实现Callable 并给一个返回值的类型
public class TestCallable implements Callable<Boolean> {private String url;private String name;public TestCallable(String url, String name) {this.url = url;this.name = name;}// 2.重写call()方法@Overridepublic Boolean call() throws Exception {PngDownloader pngDownloader = new PngDownloader();pngDownloader.downloader(url, name);System.out.println("下载了文件名为：" + name);return true;}public static void main(String[] args) throws ExecutionException, InterruptedException {TestCallable t1 = new TestCallable("http://commons.apache.org/images/commons-logo.png", "阿帕奇Logo.jpg");TestCallable t2 = new TestCallable("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1605265343111&di=bb9215e6666b513c91a0a9e4284b5adf&imgtype=0&src=http%3A%2F%2F5b0988e595225.cdn.sohucs.com%2Fimages%2F20190608%2F94ffe7706df04db4ab2fc2de10697a68.jpeg", "DockerLogo.jpg");TestCallable t3 = new TestCallable("https://timgsa.baidu.com/timg?image&quality=80&size=b9999_10000&sec=1605265313962&di=e8f6395d62c50c92d57502a0ebbe6f02&imgtype=0&src=http%3A%2F%2Fpic2.zhimg.com%2Fv2-94a00bfec307801902f81d81140a1c8a_1200x500.jpg", "MavenLogo.jpg");// 创建执行服务   new 了一个线程池 里面放3个线程ExecutorService ser = Executors.newFixedThreadPool(3);// 提交执行Future<Boolean> r1 = ser.submit(t1);Future<Boolean> r2 = ser.submit(t2);Future<Boolean> r3 = ser.submit(t3);// 获取结果boolean rs1 = r1.get();boolean rs2 = r2.get();boolean rs3 = r3.get();// 关闭服务ser.shutdownNow();}
}//=================================================================================
/*** 下载器*/
class PngDownloader {/*** 下载方法** @param url* @param name*/public void downloader(String url, String name) {try {FileUtils.copyURLToFile(new URL(url), new File(name));} catch (IOException e) {System.out.println("发生了IO异常，downloader方法出现了问题");}}
}

静态代理

静态代理模式：模拟婚庆公司代理结婚的人结婚
1. 真实对象和代理对象都要实现同一个接口
2. 代理对象必须要代理真实角色

优点：

代理对象可以做很多真实对象做不了的是
真实对象专注做自己的事情

public class StacticProxy {public static void main(String[] args) {//        WeddingCompany weddingCompany = new WeddingCompany(new You());
//        weddingCompany.HappyMarry();new WeddingCompany(new You()).HappyMarry();}
}
//=============================================================
// 结婚这件事
interface Marry {void HappyMarry();
}
//=============================================================
// 真实的角色，结婚本人结婚
class You implements Marry {@Overridepublic void HappyMarry() {System.out.println("你要结婚了！~");}
}
//=============================================================
// 婚庆公司(实现类，代理实现结婚这件事的对象，使用具体的人target来结婚)
class WeddingCompany implements Marry {// 结婚的人这个目标对象private Marry target;// 建立构造器用于初始化这个对象public WeddingCompany(Marry target) {before();this.target = target;after();}private void after() {System.out.println("收费");}private void before() {System.out.println("现场、婚房布置");}@Overridepublic void HappyMarry() {this.target.HappyMarry();}
}

`Lanmda`表达式

简介

λ是希腊字母表中排序第十一位的字母(小写λ大写Λ)，英语名称为Lambda

作用：

避免匿名内部类定义过多
其实质属于函数式编程的概念
去掉没有意义的代码，只留下核心的逻辑
让代码更简洁

函数式接口`Functional Interface`

定义

任何接口，如果只包含唯一一个抽象方法，那么他就是一个函数式接口
对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

示例：

演示从外部类简化至静态内部类—>局部内部类—>匿名内部类—>lambda表达式

public class TestLambda {// 4.简化代码：静态内部类static class Like2 implements ILike {@Overridepublic void lambda() {System.out.println("i like lambda");}}public static void main(String[] args) {// 3.输出ILike like = new Like();like.lambda();like = new Like2();like.lambda();// 5.简化代码：局部内部类class Like3 implements ILike {@Overridepublic void lambda() {System.out.println("i like lambda");}}like = new Like3();like.lambda();// 6.简化代码：匿名内部类,没有类的名称，必须借助接口或者父类// 直接new接口并且实现这个接口的方法like = new ILike() {@Overridepublic void lambda() {System.out.println("i like lambda");}};// 7.简化代码：Lambda表达式简化：jdk1.8新特性// 去掉等号到实现方法的参数括号之间的内容，参数括号与后面代码块之间加上->like = () -> {System.out.println();};like.lambda();}
}// 1.定义一个函数式接口
interface ILike {void lambda();
}// 2.实现类
class Like implements ILike {@Overridepublic void lambda() {System.out.println("i like lambda");}
}

Lambda表达式简化：

// 匿名内部类
ILove love = new ILove() {@Overridepublic void love(int a) {System.out.println();}
};
// Lambda表达式  去掉接口名以及方法名并加上->
ILove love = (int a) -> {System.out.println();
};
// 简化Lambda表达式1 去掉参数类型以及参数的括号
ILove love = a -> {System.out.println();
};
// 简化Lambda表达式2 去掉代码块括号
ILove love = a-> System.out.println();

总结

要使用Lambda表达式，接口必须是函数式接口（该接口内只有一个方法）；
当实现方法内有多行代码时，lanmbda的表达式不能去掉花括号；
当接口内方法有多个参数时，参数类型要都去掉，但是参数的包裹括号不能去

线程状态

创建

即单纯地创建一个线程，创建线程有三种方式

继承Thread类
实现Runnable接口
实现Callable接口

总结

public class ThreadNew {public static void main(String[] args) {// 启动继承Thread类的线程new TestThread1().start();// 启动实现了Runnable接口的线程new Thread(new TestTHread2()).start();// 启动实现了Callable接口的线程FutureTask<Integer> futureTask = new FutureTask<Integer>(new TestThread3());new Thread(futureTask).start();try {Integer integer = futureTask.get();System.out.println(integer);} catch (InterruptedException e) {e.printStackTrace();} catch (ExecutionException e) {e.printStackTrace();}}
}// 1.继承Thread
class TestThread1 extends Thread {@Overridepublic void run() {System.out.println("继承Thread类");}
}// 2.实现Runnable接口
class TestTHread2 implements Runnable {@Overridepublic void run() {System.out.println("实现Runable");}
}// 3.实现Callable接口
class TestThread3 implements Callable<Integer> {@Overridepublic Integer call() throws Exception {System.out.println("实现Callable接口");return 100;}
}

就绪

在创建了线程之后，调用Thread类的start()方法来启动一个线程，即表示线程进入就绪状态！

线程礼让

让当前正在执行的线程暂停，但不阻塞
将线程从运行状态转为就绪状态
让CPU重新调度，礼让不一定成功，看CPU心情！
- 线程a、b同时执行，a先进入了CPU，然后a礼让b不在CPU中执行并退出和b继续同时竞争进入CPU，此时a、b究竟谁再先进入CPU依然看CPU的心情

public class TestYield {public static void main(String[] args) {MyYield myYield = new MyYield();new Thread(myYield,"a").start();new Thread(myYield,"b").start();}
}class  MyYield implements Runnable{@Overridepublic void run() {System.out.println(Thread.currentThread().getName()+"线程开始执行");Thread.yield();System.out.println(Thread.currentThread().getName()+"线程执行完成");}
}

运行

当线程获得CPU时间，线程才从就绪状态进入到运行状态

阻塞

线程进入运行状态后，可能由于多种原因让线程进入阻塞状态，如：调用sleep()方法让线程睡眠，调用wait()方法让线程等待，调用join()方法、suspend()方法（它现已被弃用！）以及阻塞式IO方法

线程休眠`Sleep`

sleep指定当前线程阻塞的毫秒数
sleep存在异常：InterruptedException
sleep时间达到后线程进入就绪状态（.start()的时候）
sleep可以放大问题的发生性
每一个对象都有一个锁，sleep不会释放锁

sleep可以模拟网络延时，倒计时等

public class TestSleep   {public static void main(String[] args) {// 捕获这个sleep方法的异常try {tenDown();} catch (InterruptedException e) {e.printStackTrace();}}// 抛出sleep的InterruptedException异常private static void tenDown() throws InterruptedException {// 倒计时次数int num = 10;while (true){// 线程每执行一次都休眠一秒Thread.sleep(1000);System.out.println(num--);// 小于=0时退出循环if (num<=0){break;}}}
}

每一个对象都有一个锁，sleep不会释放锁

`Join`合并线程

待此线程执行完成后再执行其他线程，该线程执行时会让其他线程阻塞
join方法的本质调用的是Object中的wait方法实现线程的阻塞
可以将join方法想象成插队，使用join方法的线程可以不管其他线程的执行状态直接插队进去让它先执行，执行过程中让其他线程等它执行完，join线程执行结束后再唤醒其他线程继续执行

public class TestJoin implements Runnable {@Overridepublic void run() {for (int i = 0; i < 50; i++) {System.out.println("VIP线程来了" + i);}}public static void main(String[] args) throws InterruptedException {TestJoin testJoin = new TestJoin();Thread thread = new Thread(testJoin);thread.start();for (int i = 0; i < 20; i++) {if (i == 2) {thread.join();}System.out.println("主线程" + i);}}
}

死亡

run()方法的正常退出就让线程进入到死亡状态，还有当一个异常未被捕获而终止了run()方法的执行也将进入到死亡状态！

不推荐使用JDK提供的stop()、destroy()方法【已启用】
推荐让线程自己停止下来
建议使用一个标志位进行终止变量，当flag=false则终止线程运行

线程中断或结束后就不能再次启动

// 1.实现Runnable接口创建线程
public class TestStop implements Runnable {// 4.设置标志位，用于让进程判断是否停止private boolean flag = true;// 2.重写run方法   线程体@Overridepublic void run() {// 设置变量，记录该线程跑了多少次int i = 0;while (flag) {System.out.println("线程体运行了:" + i++);}}// 3.创建主线程public static void main(String[] args) {// 实例化本线程类放入线程Thread中去调用线程启动方法TestStop testStop = new TestStop();new Thread(testStop).start();// 6.循环判断线程停止条件是否成立for (int i = 0; i < 10; i++) {System.out.println("主线程运行了：" + i + "次");if (i == 5) {testStop.stop();System.out.println("主线程运行超过限定次数，线程体已停止");}}}// 5.重写线程的Stop方法    标志位flag为true时线程正常运行，为false时线程停止public void stop() {this.flag = false;}
}

线程状态观测

Thread.State
线程可以处于以下状态之一:

NEW
尚未启动的线程处于此状态。

RUNNABLE
在Java虚拟机中执行的线程处于此状态。

BLOCKED
被阻塞等待监视器锁定的线程处于此状态。

WAITING
正在等待另一个线程执行特定动作的线程处于此状态。

TIMED_WAITING
正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。

TERMINATED
已退出的线程处于此状态。

一个线程可以在给定时间点处于一个状态。这些状态是不反映任何操作系统线程状态的虚拟机状态

// 观测线程的状态变化
public class TestTheardState {public static void main(String[] args) throws InterruptedException {// 1.创建线程Thread thread = new Thread(() ->{// 2.sleep()阻塞线程，循环执行5次，每次让线程休眠1秒for (int i = 0; i < 5; i++) {try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}// 阻塞结束后打印信息System.out.println("===================");});// 3.使用thread.getState()获取线程状态，观察状态Thread.State state = thread.getState();// 4.输出当前线程状态（此时线程只是创建，所以是NEW状态）System.out.println(state);// 5.启动线程thread.start();// 使用thread.getState())给state重新赋值，刷新线程状态；启动线程后，线程的状态应该是就绪：RUNNABLESystem.out.println(state = thread.getState());// 6.每隔1秒监听一次线程状态，只要线程不结束就一直输出线程状态，直至线程状态等于TERMINATED为止while (state != Thread.State.TERMINATED) {Thread.sleep(1000);state = thread.getState();System.out.println(state);}}
}

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
线程的优先级用数字表示，范围从1~10
- Thread.MIN_PRIORITY = 1 ;
- Thread.MAX_PRIORITY = 10 ;
- Thread.NORM_PRIORITY = 5 ;
使用以下方式改变或获取优先级
- getPriority()
- .setPriority(int xxx)

public class TestPriority {public static void main(String[] args) {// 输出线程名字以及线程的优先级的值System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());MyPriority myPriority = new MyPriority();Thread a = new Thread(myPriority, "a");Thread b = new Thread(myPriority, "b");Thread c = new Thread(myPriority, "c");Thread d = new Thread(myPriority, "d");Thread e = new Thread(myPriority, "e");// 先设置线程的优先级再启动a.start();b.setPriority(1);b.start();c.setPriority(4);c.start();// 优先级最高：10d.setPriority(Thread.MAX_PRIORITY);d.start();// NORM_PRIORITY为默认优先级：5e.setPriority(Thread.NORM_PRIORITY);e.start();}
}// 创建一个线程类
class MyPriority implements Runnable {@Overridepublic void run() {System.out.println(Thread.currentThread().getName() + "--->" + Thread.currentThread().getPriority());}
}

守护线（daemon）程

线程分为用户线程和守护线程
虚拟机必须确保用户线程执行完毕
虚拟机不用等待守护线程执行完毕

如：后台记录操作日志、监控内存、垃圾回收等待…

public class TestDaemon {public static void main(String[] args) {God god = new God();Yous yous = new Yous();Thread thread = new Thread();// 开启守护线程thread.setDaemon(true);// 只启动用户线程  守护线程会随着用户线程的停止而停止new Thread(yous).start();}
}
// 创建神线程对象---守护线程
class God implements Runnable {// 这小子有锁血BUG@Overridepublic void run() {while (true) {System.out.println("一直活着并且守护着你");}}
}
// 创建你这个人的线程---用户线程
class Yous implements Runnable {@Overridepublic void run() {for (int i = 0; i < 200; i += 10) {System.out.println("你活了十年");}System.out.println("============ game over ===========");}
}

线程同步

同一个资源，多个线程使用

处理多线程问题时，多个线程访问同一个对象（并发），并且某些线程还想修改这个对象，这时候我们就需要线程同步

线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保证数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可。锁机制会存在以下问题:
—个线程持有锁会导致其他所有需要此锁的线程挂起

在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时,引起性能问题;（安全和性能一定是互相影响的）

如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题（执行速度快且优先级高的线程被执行速度慢且优先级低的线程先一步获得了排它锁）。

由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要针对方法提出一套机制，这套机制就是synchronized关键字，它包括两种用法∶
- synchronized方法
  - ```
  // 锁的是this，也就是类本身
  // 哪个方法在操作对象，就锁哪个方法，用synchronized来修饰它，让它变成同步方法
  public synchronized void TestSynchronized() { }
```
- synchronized块
  - ```
  // 同步块可以锁任何对象，但应该操作、修改的对象是谁就锁谁，同步监视器中就放入这个对象，然后将具体的操作、修改方法放入代码块中；锁的对象就应该是变化的量！
  synchronized (Obj) { }
```
- Obj称之为同步监视器
- Obj可以是任何对象，但是推荐使用共享资源作为同步监视器
- 同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class
synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行
synchronized影响效率
只有需要修改数据的方法才需要加锁

死锁

多个线程各自占有一些共享资源，并且相互等待其他线程战友的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情形。两个以上对象的锁”时,就可能会发生“死锁”的问题.

某一个同步块同时拥有“两个以上对象的锁”时，就可能会发生“死锁”的问题

它是隐式定义同步锁

多个线程同时各自占用着对方需要的资源，然后形成僵持、互不相让

产生死锁的四个必要条件：

互斥条件：一个资源每次只能被一个进程使用，所以两个进程同时请求一个资源会造成死锁
请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放
- 一个进程请求多个资源，当其中一个资源阻塞时，他会等待这个资源释放并重新请求，同时对之前的持有的资源不释放，直至这个资源请求完毕
不剥夺条件：进程已获得的资源，在未使用完之前，不能强行剥夺
循环等待条件：若干进程之间形成一种头尾相接的循环等待资源关系（互相请求对方所持的资源，然后僵持）

只要破解其中的任意一个或多个条件就可以避免死锁发生

// 死锁：两个线程都请求对方锁持有的资源，然后形成僵持
public class DeadLock {public static void main(String[] args) {Makeup g1 = new Makeup(0, "lisi");Makeup g2 = new Makeup(1, "zhangsan");g1.start();g2.start();}
}// 口红
class Lipstick {}// 化妆镜
class Mirror {}// 化妆
class Makeup extends Thread {// 需要的资源只有一份，用static来保证只有一份static Lipstick lipstick = new Lipstick();static Mirror mirror = new Mirror();// 选择int choice;// 化妆的人String girlName;Makeup(int choice, String girlName) {this.choice = choice;this.girlName = girlName;}@Overridepublic void run() {// 化妆try {Makeup();} catch (InterruptedException e) {e.printStackTrace();}}// 化妆，互相持有对方的锁，就是需要拿到对方的资源private void Makeup() throws InterruptedException {if (choice == 0) {synchronized (lipstick) {System.out.println(this.girlName + "获得了口红的锁)");Thread.sleep(1000);synchronized (mirror) {System.out.println(this.girlName + "获得化妆镜的锁!");}}} else {synchronized (mirror) {System.out.println(this.girlName + "获得化妆镜的锁!");Thread.sleep(2000);synchronized (lipstick) {System.out.println(this.girlName + "获得口红的锁!");}}}}
}

Lock(锁)

从JDK 5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程于始访问共享资源之前应先获得Lock对象
ReentrantLock(可重入锁)类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显式加锁、释放锁。

public class TestLock {public static void main(String[] args) {TestLock2 testLock2 = new TestLock2();// 启动三个线程new Thread(testLock2).start();new Thread(testLock2).start();new Thread(testLock2).start();}
}class TestLock2 implements Runnable {// 倒数10个数int ticketNums = 10;// 定义一个Lock锁/创建锁对象，使用private和final让这个锁更安全private final ReentrantLock lock = new ReentrantLock();@Overridepublic void run() {while (true) {// 加锁 lock.lock()要使用try{}finally{}包裹起来，lock.lock()要放在try{}的第一行try {lock.lock();// 线程执行体/业务代码放在lock.lock()下面，那么就是将这个进程加上了lockif (ticketNums > 0) {try {// 每执行一次休眠0.5sThread.sleep(500);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(ticketNums--);} else {break;}} finally {// lock.unlock() 关闭锁 和lock.lock绑定使用，紧跟finally{}第一行lock.unlock();}}}
}

`synchronized`与`Lock`的对比

Lock是显式锁（手动开启和关闭锁，别忘记关闭锁) synchronized是隐式锁，出了作用域自动释放
Lock只有代码块锁，synchronized有代码块锁和方法锁
使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性(提供更多的子类)
优先使用顺序:
- Lock
  - 同步代码块（已经进入了方法体，分配了相应资源)
    - 同步方法（在方法体之外)

线程并发协作模型：生产者消费者模式

应用场景：****生产者和消费者问题

假设仓库中只能存放一件产品，生产者将生产出来的产品放入仓库，消费者将仓库中产品取走消费掉

如果仓库中没有产品，则生产者将产出产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止

如果仓库中放有产品，则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止

这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖，互为条件

对于生产者，没有生产产品之前，要通知消费者等待。而生产了产品之后，又需要马上通知消费者消费

对于消费者,在消费之后，要通知生产者已经结束消费，需要生产新的产品以供消费

在生产者消费者问题中，仅有synchronized是不够的
synchronized可阻止并发更新同一个共享资源，实现了同步

synchronized不能用来实现不同线程之间的消息传递(通信)

Java提供了几个方法解决线程之间的通信问题

方法名	作用
`wait()`	表示线程一直等待，直到其他线程通知，作用与sleep一样，但sleep期间会占用锁，而wait会释放锁
`wait(long timeout)`	指定等待的毫秒数
`notify()`	唤醒一个处于等待状态的线程
`notifyAll()`	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

这些方法都是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常：IllegalMonitorStateException

解决方法

管程法

生产者：负责生产数据的模块（可能是方法、对象、线程、进程）
消费者：负责处理数据的模块
缓冲区：消费者不能直接使用生产者的数据，生产者也不能直接将数据给消费者他们之间有个缓冲区

生产者将生产号的数据放入缓冲区，消费者从缓冲区拿出数据

// 生产者、消费者、产品、缓冲区
public class TestPC {public static void main(String[] args) {SynContainer synContainer = new SynContainer();new Productor(synContainer).start();new Consumer(synContainer).start();}
}// 生产者
class Productor extends Thread {SynContainer container;public Productor(SynContainer container) {this.container = container;}// 生产@Overridepublic void run() {for (int i = 0; i < 100; i++) {container.push(new Chicken(i));System.out.println("生产了" + i + "只鸡");}}
}// 消费者
class Consumer extends Thread {SynContainer container;public Consumer(SynContainer container) {this.container = container;}// 消费@Overridepublic void run() {for (int i = 0; i < 100; i++) {System.out.println("消费了--》" + container.pop().ID + "只鸡");}}
}// 产品
class Chicken {int ID;public Chicken(int ID) {this.ID = ID;}
}// 缓冲区
class SynContainer {// 需要一个容器大小Chicken[] chickens = new Chicken[10];// 容器计数器int count = 0;// 生产者放入产品public synchronized void push(Chicken chicken) {// 如果容器满了，就需要等待消费者消费if (count == chickens.length) {// 通知消费者消费，生产者等待try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}// 如果没满就丢入产品chickens[count] = chicken;count++;// 可以通知消费者消费了,唤醒等待的线程this.notifyAll();}// 消费者消费产品public synchronized Chicken pop() {// 判断能否消费if (count == 0) {// 等待着生产，消费和等待}// 如果可以消费count--;Chicken chicken = chickens[count];// 吃完了通知生产者生产return chicken;}
}

信号灯法

public class TestPC2 {public static void main(String[] args) {Movie movie = new Movie();new Player(movie).start();new Watcher(movie).start();}
}// 生产者  演员
class Player extends Thread {Movie movie;public Player(Movie movie) {this.movie = movie;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {if (i % 2 == 0) {this.movie.play("小电影播放中");} else {this.movie.play("抖阴，妓录你的美好生活");}}}
}// 消费者  观众
class Watcher extends Thread {Movie movie;public Watcher(Movie movie) {this.movie = movie;}@Overridepublic void run() {for (int i = 0; i < 20; i++) {this.movie.watch();}}
}// 产品   节目
class Movie {// 表演的节目String voice;// 标志位  判断是生产者等待还是消费者等待boolean flag = true;// 演员的职能：表演        演员表演，观众等待public synchronized void play(String voice) {if (!flag) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("演员表演了：" + voice);// 通知观众观看this.notifyAll();this.voice = voice;this.flag = !this.flag;}// 观众的职能：观看       观众观看，演员等待public synchronized void watch() {if (flag) {try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}System.out.println("观众观看了：" + voice);// 通知演员表演   唤醒this.notifyAll();this.flag = !this.flag;}
}

线程池

背景:

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

思路:

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

好处:

提高响应速度（减少了创建新线程的时间)
降低资源消耗（重复利用线程池中线程，不需要每次都创建)
便于线程管理(.……)
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():关闭连接池

Executors:工具类、线程池的工厂类，用于创建并返回不同类型的线程池

示例

public class TestPool {public static void main(String[] args) {// 1.创建服务，创建线程池     newFixedThreadPool的参数为：线程池的大小，也就是能放多少线程ExecutorService service = Executors.newFixedThreadPool(10);service.execute(new MyTheard());service.execute(new MyTheard());service.execute(new MyTheard());service.execute(new MyTheard());service.execute(new MyTheard());// 2.关闭连接service.shutdown();}
}class MyTheard implements Runnable {@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}
}

Java基础---多线程宝典相关推荐

java基础-多线程应用案例展示
java基础-多线程应用案例展示作者:尹正杰版权声明:原创作品,谢绝转载!否则将追究法律责任. 一.两只熊,100只蜜蜂,蜜蜂每次生产的蜂蜜量是1,罐子的容量是30,熊在罐子的蜂蜜量达到20的时候 ...
2020 - [Java基础 +多线程 + 虚拟机] + [计网 + 操作系统] + [MySQL] + [Redis] + [RocketMQ] + [Spring]常见面试题与解析
前情提要:下面的内容主要由网上的资料和个人的理解整理而成.由于时间仓促可能没有给出相应的链接,并不代表我不尊重他人的劳动成果,后续更新会补上相应的链接.其中内容可能有理解不到位的地方,大家可选择性采纳 ...
Java基础--多线程
一.程序.进程.线程 1.区别 (1)程序是一段静态的代码,为应用程序执行的蓝本. (2)进程为程序的一次动态执行过程,包括代码的加载.执行以及执行完毕的一个完整过程. (3)线程是进程中的一个执行单 ...
黑马程序员——java基础---多线程(二)
------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 线程间的通信:简单来说,就是多个线程在操作同一资源,但操作的动作不同. 试想一下,对于同一个资 ...
java基础------多线程（转）
24.01_多线程(多线程的引入)(了解) 1.什么是线程线程是程序执行的一条路径, 一个进程中可以包含多条线程多线程并发执行可以提高程序的效率, 可以同时完成多项工作 2.多线程的应用场景红蜘 ...
10 Java基础多线程2
/* 线程间通讯: 其实就是多个线程在操作同一个资源但是操作的动作不同 */ class Res { Stringname; Stringsex; } class Input implements ...
java基础—多线程
1.Thread类 package com.wjl.base;public class MyThread extends Thread {/*** 利用继承的特点* 将线程名称传递 * @param ...
黑马程序员——Java基础---多线程
------Java培训.Android培训.iOS培训..Net培训.期待与您交流! ------- 多线程一.概述说起多线程,我们就需要首先来谈谈什么叫做进程.所谓进程,就是在计算机上正在进行 ...
黑马程序员JAVA基础-多线程
------- android培训.java培训.期待与您交流! ---------- 线程: 线程是进程中的一个独立的控制单元线程在控制着进程的执行一个进程中至少有一个线程线程的创建第一种方 ...

Java基础---多线程宝典

多线程