Java多线程详解

于 2024-03-09 17:00:33 发布
阅读量877 收藏 16
点赞数 21
文章标签： java jvm 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xzh202206/article/details/136586498
版权

目录

1、进程与线程

2、创建线程的方法

1、继承Thread类

2、实现runnable接口，重写run方法~

3、实现Callable接口（了解即可）

3、线程状态

1、停止线程

2、线程休眠

3、线程礼让

4、线程合并

5、观测线程状态

6、线程优先级

7、守护线程

8、线程同步

4、三大不安全案例

1、买票案例

2、取钱案例

3、ArrayList案例

5、线程同步方法

1、synchronized方法

2、synchronized同步块

6、JUC-CopyOnWriteArrayList

7、死锁和锁

1、死锁

2、锁

8、线程通信

1、解决方法一：管程法

2、解决方法二：信号灯法

9、线程池

1、进程与线程

  • 说起进程，就不得不说一下程序。程序是指令和数据的有序集合，其本身没有任何运行的含义，是一个静态的概念。

  • 而进程则是执行程序的一次执行过程，它是一个动态的概念。是系统资源分配的单位~

  • 通常在一个进程中可以包含多个线程，当然一个进程至少有一个线程。不然没有存在的意义。线程是CPU调度和执行的单位~

注意：很多多线程都是模拟出来的，真正的多线程是指有多个CPU，即多核，如服务器。如果是模拟出来的多线程，即在一个cpu的情况下，在同一个时间点，CPU只能执行一个代码，因为切换的很快，所以就有同时执行的错觉~

核心概念：

  • 线程就是独立的执行路径；

  • 在程序运行时，即使没有自己创建线程，后台也会有多个线程，如主线程，gc线程；

  • main()称之为主线程，为系统的入口，用于执行整个程序；

  • 在一个进程中，如果开辟了多个线程，线程的运行由调度器安排调度=，调度器是与操作系统紧密相关的，先后顺序是不能认为的干预；

  • 对同一份资源操作时，会存在资源抢夺的问题，需要加入并发控制；

  • 每个线程在自己的工作内存交互，内存控制不会造成数据不一致。

2、创建线程的方法

1、继承Thread类
 package com.study.demo01;
 ​
 //创建线程方式一：继承thread类，重写run方法，调用start开启线程
 public class TestThread extends Thread{
     @Override
     public void run() {
         //run方法线程体
         for (int i = 0; i < 20; i++) {
             System.out.println("我在看代码-"+i);
         }
     }
 ​
     public static void main(String[] args) {
         //main线程  主线程
 ​
         //创建一个线程对象
         TestThread testThread = new TestThread();
 ​
         //调用start()方法开启线程
         testThread.start();
         
         for (int i = 0; i < 20; i++) {
             System.out.println("我在学习多线程-"+i);
         }
     }
 }
 ​

运行结果：

 我在学习多线程-0
 我在学习多线程-1
 我在看代码-0
 我在学习多线程-2
 我在看代码-1
 我在看代码-2
 我在学习多线程-3
 我在学习多线程-4
 我在学习多线程-5
 我在学习多线程-6
 我在学习多线程-7
 我在学习多线程-8
 我在学习多线程-9
 我在学习多线程-10
 我在学习多线程-11
 我在看代码-3
 我在学习多线程-12
 我在看代码-4
 我在学习多线程-13
 我在看代码-5
 我在学习多线程-14
 我在看代码-6
 我在学习多线程-15
 我在看代码-7
 我在看代码-8
 我在看代码-9
 我在看代码-10
 我在看代码-11
 我在看代码-12
 我在看代码-13
 我在看代码-14
 我在学习多线程-16
 我在学习多线程-17
 我在学习多线程-18
 我在学习多线程-19
 我在看代码-15
 我在看代码-16
 我在看代码-17
 我在看代码-18
 我在看代码-19

总结：线程开启不一定立即执行，由CPU调度执行~

2、实现runnable接口，重写run方法~
 package com.study.demo01;
 ​
 //创建线程方法2：实现runnable接口，重写run方法，执行线程需要丢入runnable接口实现类。调用start方法
 public class TestThread03 implements Runnable{
     @Override
     public void run() {
         //run方法线程体
         for (int i = 0; i < 20; i++) {
             System.out.println("我在看代码~"+i);
         }
     }
 ​
     public static void main(String[] args) {
         //创建runnable接口实现类的对象
         TestThread03 testThread03 = new TestThread03();
 ​
         //创建线程对象，通过线程对象来开启我们的线程  代理
         Thread thread = new Thread(testThread03);
         thread.start();
         //new Thread(testThread03).start();
 ​
         for (int i = 0; i < 20; i++) {
             System.out.println("我在学习多线程~"+i);
         }
     }
 }
 ​

运行结果：

 我在学习多线程~0
 我在学习多线程~1
 我在学习多线程~2
 我在学习多线程~3
 我在学习多线程~4
 我在学习多线程~5
 我在学习多线程~6
 我在学习多线程~7
 我在学习多线程~8
 我在学习多线程~9
 我在学习多线程~10
 我在学习多线程~11
 我在学习多线程~12
 我在看代码~0
 我在看代码~1
 我在看代码~2
 我在看代码~3
 我在看代码~4
 我在看代码~5
 我在看代码~6
 我在看代码~7
 我在看代码~8
 我在看代码~9
 我在看代码~10
 我在看代码~11
 我在学习多线程~13
 我在看代码~12
 我在看代码~13
 我在看代码~14
 我在看代码~15
 我在看代码~16
 我在看代码~17
 我在看代码~18
 我在看代码~19
 我在学习多线程~14
 我在学习多线程~15
 我在学习多线程~16
 我在学习多线程~17
 我在学习多线程~18
 我在学习多线程~19

并发问题

 package com.study.demo01;
 //多线程同时操作同一对象
 //买火车票的例子
 ​
 public class TestThread04 implements Runnable{
 ​
     //票数
     private int ticketNum = 10;
     @Override
     public void run() {
         while(true){
             if (ticketNum<=0){
                 break;
             }
             //模拟延时~
             try {
                 Thread.sleep(200);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             System.out.println(Thread.currentThread().getName()+"-->拿到了第"+ticketNum--+"票~");
         }
     }
 ​
     public static void main(String[] args) {
         TestThread04 ticket = new TestThread04();
 ​
         new Thread(ticket,"张三").start();
         new Thread(ticket,"李四").start();
         new Thread(ticket,"王五").start();
     }
 }
 ​

运行结果：

 王五-->拿到了第10票~
 张三-->拿到了第9票~
 李四-->拿到了第10票~
 李四-->拿到了第8票~
 张三-->拿到了第7票~
 王五-->拿到了第6票~
 李四-->拿到了第4票~
 王五-->拿到了第3票~
 张三-->拿到了第5票~
 张三-->拿到了第2票~
 李四-->拿到了第0票~
 王五-->拿到了第1票~

发现问题：多线程操作同一资源的情况下，线程不安全，数据紊乱！

两种方法对比：

  • 继承Thread类

    • 子类继承Thread类具备多线程能力

    • 启动线程：子类对象.start()

    • 不建议使用：避免OOP单继承局限性

  • 实现Runnable接口：

    • 实现接口Runable就有多线程能力

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

    • 推荐使用：避免单继承局限性，灵活方便，方便同一对象被多个线程使用。

龟兔赛跑实例：

 package com.study.demo01;
 ​
 public class TestRace implements Runnable{
 ​
     //胜利者
     private static String winner;
 ​
     @Override
     public void run() {
         for (int i = 0; i <= 100; i++) {
             if (Thread.currentThread().getName().equals("兔子")){
                 try {
                     Thread.sleep(1);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             //判断比赛是否结束
             boolean flag = gameOver(i);
             //如果比赛结束，就停止程序
             if(flag){
                 break;
             }
             System.out.println(Thread.currentThread().getName()+"-->跑了"+i+"步~");
         }
 ​
     }
     //判断是否完成比赛
     private boolean gameOver(int steps){
         for (int i = 0; i < 100; i++) {
             //判断比赛是否有胜利者
             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) {
         TestRace race = new TestRace();
 ​
         new Thread(race,"兔子").start();
         new Thread(race,"乌龟").start();
     }
 }

3、实现Callable接口（了解即可）

Callable的好处：

  1. 可以定义返回值

  2. 可以抛出异常

 package com.study.demo02;
 ​
 import com.study.demo01.TestTheard02;
 ​
 import java.util.concurrent.*;
 ​
 public class TestCallable implements Callable<Boolean> {
 ​
     private String url;//网络图片地址
     private String name;//保存的文件名
     
     public TestCallable(String url,String name) {
         this.url = url;
         this.name = name;
     }
     //下载图片到执行体
     @Override
     public Boolean call() {
         WebDownloader2 webDownloader = new WebDownloader2();
         webDownloader.downloader1(url,name);
         System.out.println("下载了文件名为："+name);
         return true;
     }
 ​
     public static void main(String[] args) {
         TestCallable t1 = new TestCallable("https://i2.hdslb.com/bfs/archive/41575b1afec5305fa…a.jpg@320w_200h_1c_!web-space-index-myseries.avif","1.jpg");
         TestCallable t2 = new TestCallable("https://i0.hdslb.com/bfs/archive/756f7695bcdd43e45…8.jpg@320w_200h_1c_!web-space-index-myseries.avif","2.jpg");
         TestCallable t3 = new TestCallable("https://i2.hdslb.com/bfs/archive/0ae34a0c6347a0fd2…6.jpg@320w_200h_1c_!web-space-index-myseries.avif","3.jpg");
         
         //创建执行服务
         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 WebDownloader2{
     //下载方法
     public void downloader1(String url,String name){
         //
     }
 }

静态代理

实例：你结婚，婚庆公司代理~

 package com.study.demo02;
 ​
 import java.awt.event.WindowAdapter;
 ​
 public class StaticProxy {
 ​
     public static void main(String[] args) {
         You you = new You();//你要结婚
 ​
         new Thread(()->System.out.println("我爱你~")).start();
 ​
         new WeddingCompany(new You()).HappyMarry();
     }
 }
 interface Marry{
     void HappyMarry();
 }
 ​
 //真实角色，你去结婚
 class You implements Marry{
 ​
     @Override
     public void HappyMarry() {
         System.out.println("你要结婚了~祝福");
     }
 }
 //代理角色，帮助结婚
 class WeddingCompany implements Marry{
 ​
     //代理的角色-->真是目标角色
     private Marry target;
 ​
     public WeddingCompany(Marry target) {
         this.target = target;
     }
 ​
     @Override
     public void HappyMarry() {
         BEfore();
         this.target.HappyMarry();
         After();
     }
 ​
     private void BEfore(){
         System.out.println("婚前布置工作~");
     }
     private void After(){
         System.out.println("婚后收尾工作~");
     }
 }

运行结果：

 我爱你~
 婚前布置工作~
 你要结婚了~祝福
 婚后收尾工作~

静态代理模式总结：

  • 特点

    • 真实对象和代理对象都要实现同一接口

    • 代理对象要代理真实角色

  • 好处

    • 代理对象可以做很多真实对象做不了的事

    • 真实对象专注做自己的事情

lambda表达式：

 package com.study.demo02;
 ​
 public class Testlambda2 {
 ​
     public static void main(String[] args) {
 ​
         ILove love = (int a)->{
             System.out.println("I love you -->"+a);
         };
 ​
 ​
         love.love(520);
     }
 }
 interface ILove{
     void love(int a);
 }

lambda表达式与其他表达式对比：

 package com.study.demo02;
 ​
 public class TestLambda {
 ​
     //3.静态内部类
     static class Like2 implements Ilike{
 ​
         @Override
         public void lambda() {
             System.out.println("I like lambda2~");
         }
     }
 ​
     public static void main(String[] args) {
         Ilike like = new Like();
         like.lambda();
 ​
         like = new Like2();
         like.lambda();
 ​
         //4.局部内部类
         class Like3 implements Ilike{
 ​
             @Override
             public void lambda() {
                 System.out.println("I like lambda3~");
             }
         }
         like = new Like3();
         like.lambda();
 ​
         //5.匿名内部类,没有类的名称，必须借助接口或者父类~
         like = new Ilike(){
             @Override
             public void lambda() {
                 System.out.println("I like lambda4~");
             }
         };
         like.lambda();
 ​
         //6.用lambda简化
         like = ()->{
             System.out.println("I like lambda5~");
         };
         like.lambda();
     }
 }
 //1.定义一个接口
 interface Ilike{
     void lambda();
 }
 //2.实现类
 class Like implements Ilike{
 ​
     @Override
     public void lambda() {
         System.out.println("I like lambda1~");
     }
 }

运行结果：

 I like lambda1~
 I like lambda2~
 I like lambda3~
 I like lambda4~
 I like lambda5~

lambda表达式总结：

lambda表达式只能有一行代码的情况下才能简化为一行，如果有多行，那么就用代码块包裹，前提是接口为函数式接口；多个参数也可去掉参数类型，要去掉就都去掉，必须加上括号~

3、线程状态
1、停止线程

 package com.study.state;
 ​
 public class TestStop implements Runnable{
 ​
     //1.设置一个标志位
     private boolean flag = true;
 ​
 ​
     @Override
     public void run() {
         int i = 0;
         while(flag){
             System.out.println("run......Thread"+i);
         }
     }
     //2.设置一个公开的方法停止线程，转换标志位
     public void stop(){
         this.flag = false;
     }
 ​
     public static void main(String[] args) {
         TestStop testStop = new TestStop();
         new Thread(testStop).start();
 ​
         for (int i = 0; i < 1000; i++) {
             System.out.println("main"+i);
             if(i==900){
                 //调用stop方法切换标志位。让线程停止
                 testStop.stop();
                 System.out.println("线程停止了");
             }
         }
     }
 }

当i执行到900以后时，标志位变为false，System.out.println("run......Thread"+i);将不再执行！

注意：

  1. 建议线程正常停止-->利用次数，不建议死循环

  2. 建议使用标志位-->设置一个标志位

  3. 不要使用stop或者destroy等过时或者JDK不建议使用的方法

2、线程休眠

 //模拟倒计时
 package com.study.state;
 ​
 public class TestSleep {
 ​
     public static void main(String[] args) {
         try {
             tenDown();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }
     public static void tenDown() throws InterruptedException {
         int num = 10;
         while(true){
             Thread.sleep(1000);
             System.out.println(num--);
             if(num<=0){
                 break;
             }
         }
     }
 }

动态打印系统时间

 package com.study.state;
 ​
 import java.text.SimpleDateFormat;
 import java.util.Date;
 ​
 public class TestSleep {
 ​
     public static void main(String[] args) {
         //打印当前系统的时间
         Date startTime = new Date(System.currentTimeMillis());//获取系统当前时间
 ​
         while(true){
             try {
                 Thread.sleep(1000);
                 System.out.println(new SimpleDateFormat("HH:mm:ss").format(startTime));
                 startTime = new Date(System.currentTimeMillis());//更新当前时间
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
 }

3、线程礼让

 package com.study.state;
 ​
 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{
 ​
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName()+"线程开始执行");
         Thread.yield();//礼让
         System.out.println(Thread.currentThread().getName()+"线程停止执行");
     }
 }

注意：礼让不一定成功，看cpu心情~

4、线程合并

 package com.study.state;
 ​
 public class TestJoin implements Runnable{
     @Override
     public void run() {
         for (int i = 0; i < 1000; 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 < 1000; i++) {
             if (i==100){
                 thread.join();//插队
             }
             System.out.println("main"+i);
         }
     }
 }

5、观测线程状态

运行时可能进行休眠进入阻塞状态或者进入死亡状态

 package com.study.state;
 ​
 //观察测试线程的状态
 public class TestState {
 ​
     public static void main(String[] args) throws InterruptedException {
         Thread thread = new Thread(()->{
             for (int i = 0; i < 2; i++) {
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
             }
             System.out.println("///");
         });
 ​
         //观察状态
         Thread.State state = thread.getState();
         System.out.println(state);//New
 ​
         //观察启动后
         thread.start();//启动线程
         state = thread.getState();
         System.out.println(state);//Run
 ​
         while (state!=Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
             Thread.sleep(100);
             state = thread.getState();//更新线程状态
             System.out.println(state);
         }
     }
 }

运行结果

 NEW
 RUNNABLE
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 TIMED_WAITING
 ///
 TERMINATED

6、线程优先级


 package com.study.state;
 ​
 public class TestPriority {
 ​
     public static void main(String[] args) {
         //主线程默认优先级
         System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
 ​
         MyPriority myPriority = new MyPriority();
 ​
         Thread t1 = new Thread(myPriority);
         Thread t2 = new Thread(myPriority);
         Thread t3 = new Thread(myPriority);
         Thread t4 = new Thread(myPriority);
         Thread t5 = new Thread(myPriority);
         Thread t6 = new Thread(myPriority);
 ​
         //先设置优先级
         t1.start();
 ​
         t2.setPriority(1);
         t2.start();
 ​
         t3.setPriority(4);
         t3.start();
 ​
         t4.setPriority(Thread.MAX_PRIORITY);//最大优先级10
         t4.start();
 ​
         t5.setPriority(8);
         t5.start();
 ​
         t6.setPriority(7);
         t6.start();
 ​
     }
 }
 class MyPriority implements Runnable{
 ​
     @Override
     public void run() {
         System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
 ​
     }
 }

7、守护线程


 package com.study.state;
 ​
 //测试守护线程
 //上帝守护你
 public class TestDaemon {
 ​
     public static void main(String[] args) {
         God god = new God();
         You you = new You();
 ​
         Thread thread = new Thread(god);
         thread.setDaemon(true);//默认时false表示用户线程，正常的线程都是用户线程
 ​
         thread.start();
 ​
         new Thread(you).start();
     }
 }
 //上帝
 class God implements Runnable{
 ​
     @Override
     public void run() {
         while (true){
             System.out.println("上帝保佑你~");
         }
     }
 }
 //你
 class You implements Runnable{
 ​
     @Override
     public void run() {
         for (int i = 0; i < 36500; i++) {
             System.out.println("快乐每一天~");
         }
         System.out.println("=======Goodbye! world=======");
     }
 }

总结：在用户线程（你）执行完成后，守护线程（上帝）也会随之结束，尽管上帝线程执行条件恒为真~

8、线程同步


利用队列和锁实现线程同步，详见同步方法及同步块

4、三大不安全案例

1、买票案例
 package com.study.Syn;
 ​
 public class UnsafetyBuyTicket {
 ​
     public static void main(String[] args) {
         BuyTicket station = new BuyTicket();
 ​
         new Thread(station,"苦逼的我").start();
         new Thread(station,"牛逼的你们").start();
         new Thread(station,"可恶的黄牛党").start();
     }
 }
 class BuyTicket implements Runnable{
 ​
     //票
     private int ticketNums = 10;
     boolean flag = true;//外部停止方式
     @Override
     public void run() {
         //买票
         while(flag){
             try {
                 buy();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
     private void buy() throws InterruptedException {
         //判断是否有票
         if (ticketNums<=0){
             flag = false;
             return;
         }
         //模拟延时
         Thread.sleep(100);
 ​
         //买票
         System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
     }
 }

问题：出现不同的人买到同一张票！

2、取钱案例
 package com.study.Syn;
 ​
 public class UnsafetyBank {
     public static void main(String[] args) {
         //账户
         Account account = new Account(100, "结婚基金");
 ​
         Drawing zhangsan = new Drawing(account, 50, "张三");
         Drawing lisi = new Drawing(account, 100, "李四");
 ​
         zhangsan.start();
         lisi.start();
 ​
     }
 }
 class Account{
     int money;//余额
     String name;//卡名
 ​
     public Account(int money,String name) {
         this.money = money;
         this.name = name;
     }
 }
 ​
 class Drawing extends Thread{
 ​
     Account account;//账户
     //取了多少钱
     int drawingMoney;
     //现在手里有多少钱
     int nowMoney;
 ​
     public Drawing(Account account,int drawingMoney,String name) {
         super(name);
         this.account = account;
         this.drawingMoney = drawingMoney;
     }
 ​
     //取钱
     @Override
     public void run() {
         //判断有没有钱
         if (account.money-drawingMoney<0){
             System.out.println(Thread.currentThread().getName()+"钱不够，取不了~");
             return;
         }
 ​
         //sleep放大问题的发生性
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 ​
         //卡内余额=余额-你取的钱
         account.money = account.money - drawingMoney;
         //你手里的钱
         nowMoney = nowMoney + drawingMoney;
 ​
         System.out.println(account.name+"余额为："+account.money);
         //Thread.currentThread().getName()=this.getName()
         System.out.println(this.getName()+"手里的钱："+nowMoney);
     }
 }

问题：余额出现负数

3、ArrayList案例
 package com.study.Syn;
 ​
 import java.util.ArrayList;
 ​
 //线程不安全的集合
 public class UnsafetyLisr {
     public static void main(String[] args) {
         ArrayList<String> list = new ArrayList<>();
         for (int i = 0; i < 10000; i++) {
             new Thread(()->{
                 list.add(Thread.currentThread().getName());
             }).start();
         }
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(list.size());
     }
 }

问题：集合大小与预想不一致

5、线程同步方法
1、synchronized方法

买票案例改进

 package com.study.Syn;
 ​
 //不安全的买票
 //线程不安全，有负数~
 public class UnsafetyBuyTicket {
 ​
     public static void main(String[] args) {
         BuyTicket station = new BuyTicket();
 ​
         new Thread(station,"苦逼的我").start();
         new Thread(station,"牛逼的你们").start();
         new Thread(station,"可恶的黄牛党").start();
     }
 }
 class BuyTicket implements Runnable{
 ​
     //票
     private int ticketNums = 10;
     boolean flag = true;//外部停止方式
     @Override
     public void run() {
         //买票
         while(flag){
             try {
                 buy();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
     //synchronized同步方法，锁的是this
     private synchronized void buy() throws InterruptedException {
         //判断是否有票
         if (ticketNums<=0){
             flag = false;
             return;
         }
         //模拟延时
         Thread.sleep(1000);
 ​
         //买票
         System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
     }
 }
2、synchronized同步块

取钱案例改进

 package com.study.Syn;
 ​
 public class UnsafetyBank {
     public static void main(String[] args) {
         //账户
         Account account = new Account(100, "结婚基金");
 ​
         Drawing zhangsan = new Drawing(account, 50, "张三");
         Drawing lisi = new Drawing(account, 100, "李四");
 ​
         zhangsan.start();
         lisi.start();
 ​
     }
 }
 class Account{
     int money;//余额
     String name;//卡名
 ​
     public Account(int money,String name) {
         this.money = money;
         this.name = name;
     }
 }
 ​
 class Drawing extends Thread{
 ​
     Account account;//账户
     //取了多少钱
     int drawingMoney;
     //现在手里有多少钱
     int nowMoney;
 ​
     public Drawing(Account account,int drawingMoney,String name) {
         super(name);
         this.account = account;
         this.drawingMoney = drawingMoney;
     }
     //取钱
     @Override
     public void run() {
         synchronized (account){
             //判断有没有钱
             if (account.money-drawingMoney<0){
                 System.out.println(Thread.currentThread().getName()+"钱不够，取不了~");
                 return;
             }
             //sleep放大问题的发生性
             try {
                 Thread.sleep(1000);
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             //卡内余额=余额-你取的钱
             account.money = account.money - drawingMoney;
             //你手里的钱
             nowMoney = nowMoney + drawingMoney;
 ​
             System.out.println(account.name+"余额为："+account.money);
             //Thread.currentThread().getName()=this.getName()
             System.out.println(this.getName()+"手里的钱："+nowMoney);
         }
     }
 }

ArrayList案例改进

 package com.study.Syn;
 ​
 import java.util.ArrayList;
 ​
 //线程不安全的集合
 public class UnsafetyLisr {
     public static void main(String[] args) {
         ArrayList<String> list = new ArrayList<>();
         for (int i = 0; i < 10000; i++) {
             new Thread(()->{
                 synchronized (list){
                     list.add(Thread.currentThread().getName());
                 }
             }).start();
         }
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(list.size());
     }
 }

6、JUC-CopyOnWriteArrayList

测试集合（不使用synchronized同步代码块方法）

 package com.study.Syn;
 ​
 import java.util.concurrent.CopyOnWriteArrayList;
 //测试JUC安全类型的集合
 public class TestJUC {
     public static void main(String[] args) {
         CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<>();
         for (int i = 0; i < 10000; i++) {
             new Thread(()->{
                     list.add(Thread.currentThread().getName());
             }).start();
         }
         try {
             Thread.sleep(1000);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println(list.size());
     }
 }

7、死锁和锁
1、死锁

 package com.study.lock;
 ​
 //死锁：多个线程互相抱着对方需要的资源，然后形成僵持
 public class DeadLock {
 ​
     public static void main(String[] args) {
         MakeUp g1 = new MakeUp(0,"灰姑凉");
         MakeUp g2 = new MakeUp(1,"白雪公主");
 ​
         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.girlName = girlName;
         this.choice = choice;
     }
 ​
     @Override
     public 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 + "获得口红的锁~");
             }
 ​
             }
         }
     }
 }

运行结果为：

 灰姑凉获得口红的锁~
 白雪公主获得镜子的锁~
 ​

此时变为了死锁，程序无法正常运行！

将makeup()函数改成如下：

 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 + "获得口红的锁~");
             }
         }
     }

运行结果为：

 灰姑凉获得口红的锁~
 白雪公主获得镜子的锁~
 白雪公主获得口红的锁~
 灰姑凉获得镜子的锁~
     

此时程序运行是没有问题的

2、锁

 package com.study.lock;
 ​
 import java.util.concurrent.locks.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{
 ​
     int ticketNums = 10;
 ​
 ​
     @Override
     public void run() {
         while(true){
                 if (ticketNums>0){
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println(ticketNums--);
                 }
                 else{
                     break;
                 }
             }
         }
 }

此时会出现多个资源操作同一对象，是不安全的！

依据锁的使用方法，修改TestLock2类如下

 class TestLock2 implements Runnable{
 ​
     int ticketNums = 10;
 ​
     //定义lock锁
     private final ReentrantLock lock = new ReentrantLock();
 ​
     @Override
     public void run() {
         while(true){
             try{
                 lock.lock();//加锁
                 if (ticketNums>=0){
                     try {
                         Thread.sleep(1000);
                     } catch (InterruptedException e) {
                         e.printStackTrace();
                     }
                     System.out.println(ticketNums--);
                 }
                 else{
                     break;
                 }
             }finally {
                 //解锁
                 lock.unlock();
             }
         }
     }
 }

此时，代码是正常运行的~

总结对比

8、线程通信


对于线程通信，Java提供了几个解决方法：

1、解决方法一：管程法

生产者消费者实例：利用缓冲区解决--管程法

 package com.study.HighLevel;
 ​
 public class TestPC {
     public static void main(String[] args) {
         SynContainer container = new SynContainer();
 ​
         new Productor(container).start();
         new Consumer(container).start();
 ​
     }
 }
 //生产者
 class Productor extends Thread{
     SynContainer container;
 ​
     public Productor(SynContainer container) {
         this.container = container;
     }
     //生产
     @Override
     public void run() {
         for (int i = 0; i < 100; i++) {
             System.out.println("生产了-->"+i+"只鸡");
             container.push(new Chicken(i));
         }
     }
 }
 //消费者
 class Consumer extends Thread{
     SynContainer container;
 ​
     public Consumer(SynContainer container) {
         this.container = container;
     }
 ​
     //消费
 ​
     @Override
     public 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.notify();
     }
 ​
     //消费者消费产品
     public synchronized Chicken pop(){
         //判断能否消费
         if (count==0){
             //等待生产者生产
             try {
                 this.wait();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
         //如果可以消费
         count--;
         Chicken chicken = chickens[count];
 ​
         //吃完就通知生产者生产
         this.notify();
         return chicken;
     }
 }

2、解决方法二：信号灯法

生产者消费者实例：信号灯法，标志位解决

 package com.study.HighLevel;
 ​
 public class TestPC2 {
     public static void main(String[] args) {
         TV tv = new TV();
         new Player(tv).start();
         new Watcher(tv).start();
     }
 }
 class Player extends Thread{
     TV tv;
 ​
     public Player(TV tv) {
         this.tv = tv;
     }
 ​
     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {
             if(i%2 == 0){
                 this.tv.play("快乐大本营播放中");
             }else{
                 this.tv.play("抖音：记录美好生活");
             }
         }
     }
 }
 class Watcher extends Thread{
     TV tv;
 ​
     public Watcher(TV tv) {
         this.tv = tv;
     }
 ​
     @Override
     public void run() {
         for (int i = 0; i < 20; i++) {
             tv.watch();
         }
     }
 }
 ​
 class TV{
     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.notify();
         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.notify();
         this.flag = !this.flag;
     }
 }

9、线程池

线程池使用背景：

线程池使用方法：

重点：ExecutorService、Executor

 package com.study.HighLevel;
 ​
 import java.util.concurrent.Executor;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 ​
 public class TestPool {
 ​
     public static void main(String[] args) {
         //1.创建服务，创建线程池
         //newFixedThreadPool 参数为：线程池大小
         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());
     }
 }

Commons-IO下载教程

‘乊丆’
关注
  • 21
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【Java篇】多线程详解
zhangxia_的博客
05-19 1万+
Java系统在语言层次上对多线程直接提供支持，多线程的主要目的是将一个程序中的各个程序段并发化，在在通常情况下，Java程序各部分是按顺序一次执行的，由于某种原因，需要将这些按顺序执行的程序段转化为并发执行，每个程序段在逻辑上是相互完整的代码段。实际上，在单处理器上，同一时刻只能执行一个代码，但是在同一时间段内，这些代码交替执行，所谓的“微观串行，宏观并行”。...
Java多线程
Lucky_YanHao
09-20 157
Java多线程基本概念：程序，进程，线程使用多线程的优点线程的创建和使用线程的声明周期线程的同步线程的通信JDK5.0新增线程创建方式 基本概念：程序，进程，线程 程序(program)： 是为完成特定任务，用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process)： 是程序的一次执行过程，或是正在运行的一个程序。 是一个动态的过程：有它自身的产生，存在和消亡的过程。------声明周期 如：运行中的QQ，运行中的MP3播放器 程序是静态的，进程是动态的 进程作为资源分配的单位
JAVA多线程详解（超详细）
热门推荐
七星太极阵的博客
08-05 2万+
线程简介，线程的创建方式，多线程并发问题
Java多线程详细讲解
cnctcom的博客
11-08 386
本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。在这之前，首先让我们来了解下在操作系统中进程和线程的区别： 　　进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。（进程是资源分配的最小单位） 　　线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切
java多线程详细讲解
06-14
java多线程讲解，非常全面的讲解，讲解内容通俗易懂！
Java多线程详解及示例
最新发布
07-20
本文将深入探讨Java多线程编程的重要性和使用方法。介绍多线程概念，讨论多线程的优势，并提供实际示例。此外，还将探讨多线程编程中的常见问题以及如何避免这些问题。通过本文，您将获得对Java多线程编程的全面理解...
Java多线程详解（超详细）_狂神说笔记完整版_项目代码_适合小白随课程学习
08-08
学习目录：1. 线程简介 2. 线程实现（重点） 3. 线程状态 4. 线程同步（重点） 5. 线程通信问题 6. 高级主题
java 多线程详解
03-20
NULL 博文链接：https://jiahua8859-163-com.iteye.com/blog/825579
java多线程讲解_Java多线程详解
weixin_34942785的博客
02-16 75
基本概念多线程：指的是这个程序(一个进程)运行时产生了不止一个线程并行：多个cpu实例或者多台机器同时执行一段处理逻辑，是真正的同时。并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源，那么针对这个公用的资源往往产生瓶颈，我们会用TPS或者QPS来反应这个系统的处理能力。线程安全：指在并发的情况之下，该代码经过多线程使用，线程的调度顺...
java多线程详解
L2818916441的博客
04-30 276
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、基本概念？二、线程的调度三、线程的生命周期四、创建线程的两种方式五、常用方法六、守护线程七、多线程数据的共享八、多线程同步处理方式一互斥锁注意：死锁释放锁 一、基本概念？ 程序：是为了完成特定的任务，而用某种语言编写的一组指令的集合，即指一段静态的代码，静态的对象。 进程：是指运行中的程序，比如我们使用QQ时，就启动了一个进程，操作系统就会为该进程分配内存空间，当我们使用微信时，又启动了一个进程，操作系统将再次为其分配内存空.
java多线程相关知识讲解
qq_63889673的博客
04-02 358
线程和进程的生命周期是一样的分为5个阶段创建、就绪、运行、阻塞、终止。对于在java中实现多线程的方法。有3种 分别是一般来说前两种使用的比较多。第三种方法使用的比较少一点。具体原因是：实现Callable接口需要使用Future和ExecutorService等类来执行任务，并且需要额外的代码来处理返回值和异常。相比于继承Thread类或实现Runnable接口，实现Callable接口需要更多的代码量，相对也更加复杂。但是这个方法也有它的使用场景，比如下面这些。
Java多线程详解（很详细）
西风小焦的博客
05-25 1747
Java多线程详解
Java多线程详解（线程池）
易果啥笔的博客
09-03 926
嗨喽～小伙伴们我来了， 上一章我们介绍了Java的Thread类里一些常用的方法。本节课我们就来聊一聊线程池。
Java多线程超详细讲解（看这个就够了）
GQH498的博客
07-15 276
进程与线程 进程是程序的一次动态执行过程，它需要经历从代码加载，代码执行到执行完毕的一个完整的过程，这个过程也是进程本身从产生，发展到最终消亡的过程。多进程操作系统能同时达运行多个进程（程序），由于 CPU 具备分时机制，所以每个进程都能循环获得自己的CPU 时间片。由于 CPU 执行速度非常快，使得所有程序好像是在同时运行一样。 多线程是实现并发机制的一种有效手段。进程和线程一样，都是实现并发的一个基本单位。线程是比进程更小的执行单位，线程是进程的基础之上进行进一步的划分。所谓多线程是指一个进程在
Java-多线程机制详解（二）
Jack__Frost的博客
10-14 1422
上篇文章多线程机制详解（一） 讲了多线程的相关概念以及创建启动。而这一篇文章将会更加深入去整理多线程机制体系，涉及的运用技巧就是我们项目开发需要使用的，同时重点点出开发项目时候的使用技巧推荐。文章结构（结合疯狂java讲义总结）：1.线程控制；2.线程同步；3.线程通信；4.线程组与线程池（项目运用）
Java多线程之深入理解并发编程基础
chenliguan的博客
12-22 895
1 概念 　　多进程是指系统能同时运行多个任务（程序）。多线程是指在同一程序中有多个顺序流在执行。例如：在编辑或下载邮件的同时可以打印文件。 　　我的另一篇文章：Java基础之详解Thread与Runnable 1.1 进程与线程区别 　　进程和线程都是一个时间段的描述，是CPU工作时间段的描述，不过是颗粒大小不同。 本质的区别在于每个进程拥有独立的内存单元；而线程则共享内存，共享...
java多线程详解及相关介绍
04-12
好的，关于Java多线程的详解和相关介绍，其实它是Java开发中非常重要的一个知识点，它可以让程序在运行过程中同时执行多个任务，从而提高程序效率和性能。要想深入学习Java多线程，需要掌握线程的基本概念和属性、线程的创建和启动、线程的同步和互斥、线程的通信和协作等方面的知识。如果您对此感兴趣，可以去学习一下Java多线程编程的相关课程，相信会有很大的收获。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值