devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Thread多线程(创建，方法，安全，通信，线程池，并发，并行，线程的生命周期)【全详解】

作者：花生_TL007 | 2024-03-07 11:40:08

赞

踩

Thread多线程(创建，方法，安全，通信，线程池，并发，并行，线程的生命周期)【全详解】

目录

1.多线程概述

2.多线程的创建

3.Thread的常用方法

4.线程安全

5.线程同步

6.线程通信

7.线程池

8.其它细节知识：并发、并行

9.其它细节知识：线程的生命周期   

1.多线程概述

        线程是什么？

                线程(Thread)是一个程序内部的一条执行流程。

                程序中如果只有一条执行流程，那这个程序就是单线程的程序。

        多线程是什么？

                多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）。

2.多线程的创建

        方式一：继承Thread类

        实现步骤：

                定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法

                创建MyThread类的对象

                调用线程对象的start()方法启动线程（启动后还是执行run方法的）

        代码实现

        

  1. package com.itheima.day11.teacher.thread01;
  2. /*
  3.   start()  开启新线程的方法   ---  线程开启功能
  4.   run()  线程执行的代码       ---  线程任务
  5.    继承方法
  6.        MyThread 既是一个线程对象(负责线程开启)  又是一个线程任务(写需要执行线程任务)
  7.        耦合性高！！
  8.        线程对象 -- 线程任务 分离！！
  9.  */
  10. public class MyThread extends Thread{
  11.  
  12.     @Override
  13.     public void run() {
  14.         /*
  15.           每个新的线程 都循环输出 十次
  16.          */
  17.         for (int i = 0; i < 10; i++) {
  18.            // 代码执行过程中 可以获取到当前正在运行的线程对象
  19.             Thread thread = Thread.currentThread();
  20.             System.out.println("新的线程"+thread.getName()+"正在执行"+i);
  21.         }
  22.     }
  23. }
  24.  
  25.  
  26. -----------------------
  27. package com.itheima.day11.teacher.thread01;
  28.  
  29. public class Test {
  30.  
  31.     public static void main(String[] args) {
  32.         System.out.println("当前是一个程序的入口"+Thread.currentThread().getName());
  33.         System.out.println("程序入口也是一个线程 这个线程叫主线程..");
  34.  
  35.         //主线程执行过程中 再产生新的线程。
  36.         /*
  37.           线程的创建方式一
  38.               1: 创建一个类 继承 Thread线程类
  39.               2: 手动重写run方法。----就是新的线程对象要执行的内容.
  40.               3: 创建 子类对象(线程对象)。
  41.               4: 调用start方法 开启这个新的线程。
  42.               当开启完了 程序中出现两个线程了 一个是 主线程  一个新建的线程。
  43.               每个线程将来都是独立的空间。
  44.          */
  45.         MyThread t1 = new MyThread();
  46.         t1.start();
  47.         // 开启新的线程
  48.  
  49.         for (int i = 0; i < 10; i++) {
  50.             System.out.println("线程"+Thread.currentThread().getName()+"正在执行"+i);
  51.         }
  52.     }
  53. }
  54.  
  55.  
  56. --------------------
  57. package com.itheima.day11.teacher.thread01;
  58.  
  59. public class Test2 {
  60.     /*
  61.             线程的创建方式一
  62.                 1: 创建一个类 继承 Thread线程类
  63.                 2: 手动重写run方法。----就是新的线程对象要执行的内容.
  64.                 3: 创建 子类对象(线程对象)。
  65.                 4: 调用start方法 开启这个新的线程。
  66.                 当开启完了 程序中出现两个线程了 一个是 主线程  一个新建的线程。
  67.                 每个线程将来都是独立的空间。
  68.             多个线程执行
  69.                每次执行效果 不尽相同 因为 CPU的高速切换 没有规律
  71.              Thread 代表线程对象的类
  72.                 Thread.currentThread() 获取 执行当前代码的线程。
  73.              普通方法
  74.                  getName() 获取线程的名字 名字默认 Thread-0  Thread-1 ....
  75.                  可以设置名字
  76.                  setName("...")
  77.            */
  78.     public static void main(String[] args) {
  79.         //程序入口也是一个线程 这个线程叫主线程..
  80.         System.out.println("当前是一个程序的入口"+Thread.currentThread().getName());
  81.         //主线程执行过程中 再产生新的线程。
  82.         MyThread t1 = new MyThread();
  83.         t1.setName("小迪迪");
  84.         t1.start();
  85.         // 开启新的线程
  86.  
  87.         // 这还是main中
  88.         for (int i = 0; i < 10; i++) {
  89.             System.out.println("线程"+Thread.currentThread().getName()+"正在执行"+i);
  90.         }
  91.     }
  92. }

                优缺点：

                        优点：编码简单

                        缺点：存在单继承的局限性，线程类继承Thread后，不能继承其他类，不便于扩展

        方式二：实现Runnable接口

                实现步骤：

                        定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法

                        创建MyRunnable任务对象

                        把MyRunnable任务对象交给Thread处理。

                        调用线程对象的start()方法启动线程

  1. package com.itheima.day11.teacher.thread02;
  2. /*
  3.   线程任务类 里面只有线程任务 run方法
  4.  */
  5. public class    MyRunnable implements Runnable{
  6.     @Override
  7.     public void run() {
  8.  
  9.         for (int i = 0; i < 10; i++) {
  10.             System.out.println("当前在"+Thread.currentThread().getName()+"正在输出:"+i);
  11.         }
  12.  
  13.     }
  14. }
  15.  
  16.  
  17. -------------------------
  18. package com.itheima.day11.teacher.thread02;
  19.  
  20. public class RunnableTest {
  21.     /*
  22.       创建线程方式二
  23.            1: 定义一个实现Runnable接口的 线程任务类,重写run方法。
  24.            2: 创建一个线程任务对象。
  25.            3: 创建线程对象 并在构造中传递线程任务对象。
  26.            4: 开启新的线程 线程对象.start()
  27.      */
  28.     public static void main(String[] args) {
  29.         // 创建线程任务对象
  30.         MyRunnable mr = new MyRunnable();
  31.         // 创建线程对象的同时 将线程任务传递过去 --- 线程和任务绑定
  32.         Thread t = new Thread(mr);
  33.         //调用start方法
  34.         t.start();
  35.  
  36.         //主线程操作
  37.         for (int i = 0; i <10 ; i++) {
  38.             System.out.println("当前在"+Thread.currentThread().getName()+"正在输出:"+i);
  39.         }
  40.  
  41.     }
  42. }
  43.  
  44.  
  45. --------------------
  46. package com.itheima.day11.teacher.thread02;
  47.  
  48. public class RunnableTest2 {
  49.     /*
  50.       创建线程方式二
  51.            1: 定义一个实现Runnable接口的 线程任务类,重写run方法。
  52.            2: 创建一个线程任务对象。
  53.            3: 创建线程对象 并在构造中传递线程任务对象。
  54.            4: 开启新的线程 线程对象.start()
  55.      */
  56.     public static void main(String[] args) {
  57.         // 创建线程任务对象
  58.         MyRunnable mr = new MyRunnable();
  59.         //上面的操作 创建了一个外部类 实现了接口 并创建该外部类的对象  外部类对象---Runnabel接口的实现类对象
  60.         // 创建线程对象的同时 将线程任务传递过去 --- 线程和任务绑定
  61.         Thread t1 = new Thread(mr);//mr 是 Runnable接口的实现类对象
  62.         //调用start方法
  63.         t1.start();
  64.  
  65.         //
  66. //        Thread t2  = new Thread(匿名内部类形式)  匿名内部类本质  子类对象
  67.         Thread t2 = new Thread(new Runnable() {
  68.             @Override
  69.             public void run() {
  70.                 for (int i = 0; i < 10; i++) {
  71.                     System.out.println("当前在"+Thread.currentThread().getName()+"正在输出:"+i);
  72.                 }
  73.             }
  74.         });
  75.         t2.start();
  76.  
  77.         // 能不能用lambda  可以
  78.         // lambda  作用简化匿名内部类   使用前提 参数是一个函数式接口  函数式接口 有且只有一个抽象方法的接口
  79.  
  80.         new Thread(()->{
  81.             for (int i = 0; i < 10; i++) {
  82.                 System.out.println("当前在"+Thread.currentThread().getName()+"正在输出:"+i);
  83.             }
  84.         }).start();
  85.  
  86.     }
  87. }

                优缺点：

                        优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。 

                        缺点：需要多一个Runnable对象。

        方式三：实现Callable接口  

        实现步骤：

        1.创建任务对象：

                1.定义一个类实现Callable接口，重写call方法，封装要做的事情和要返回的数据。        

                2.把Callable类型的对象封装成FutureTask对象（线程任务对象）。

         2.把线程任务对象封装成Thread对象。

         3.调用Thread对象的start方法启动线程。

         4.线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。

 

  1. package com.itheima.day11.teacher.thread03;
  2.  
  3. import java.util.concurrent.Callable;
  4.  
  5. /*
  6.    Callable接口有个泛型 表示 返回的结果类型。
  8.       返回值 call
  9.  */
  10. public class MyCallable implements Callable<Integer> {
  11.  
  12.     // 构造   方法 都可以访问 成员变量
  13.     private Integer number;
  14.  
  15.     public MyCallable(Integer number){
  16.         // 当能够调用call方法的时候  构造方法执行完了
  17.         // 方法中没有参数  构造中可不可以设计参数
  18.         // 把构造中传递的number 赋值给成员变量
  19.         this.number = number;
  20.     }
  21.  
  22.     //任务 求一个数的 绝对值
  23.     @Override
  24.     public Integer call() throws Exception {
  25.  
  26.         System.out.println("当前的线程:"+Thread.currentThread().getName());
  27.  
  28.         return Math.abs(number);//直接使用
  29.     }
  30.  
  31.  
  32. }
  33.  
  34.  
  35. -----------------------
  36. package com.itheima.day11.teacher.thread03;
  37.  
  38. import java.util.concurrent.Callable;
  39.  
  40. /*
  41.    Callable接口有个泛型 表示 返回的结果类型。
  43.       返回值 call
  44.  */
  45. public class MyCallable1 implements Callable<String> {
  46.     //任务 求一个数的 绝对值
  47.     @Override
  48.     public String call() throws Exception {
  49.  
  50.         System.out.println("当前的线程:"+Thread.currentThread().getName());
  51.  
  52.         return "下载任务执行成功";//直接使用
  53.     }
  54. }
  55.  
  56.  
  57. -----------------------
  58. package com.itheima.day11.teacher.thread03;
  59.  
  60. import java.util.concurrent.Callable;
  61. import java.util.concurrent.ExecutionException;
  62. import java.util.concurrent.FutureTask;
  63.  
  64. public class CallableTest {
  65.     /*
  66.       创建线程方式三
  67.           1:创建子类实现Callable接口 完成call方法重写。
  68.           2:创建线程任务（自定义callable）对象.
  69.           3:创建一个 线程任务管理对象 FutureTask封装 callable实现对象。
  70.           4:创建线程对象 绑定线程任务管理对象
  71.           5:调用start方法
  72.      */
  73.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  74.         //创建线程任务对象
  75.         MyCallable my = new MyCallable(-10);//带参构造
  76.         //传参给 Thread 创建线程对象
  77. //        Thread thread = new Thread(my);
  78.         // Callable 是一个带有返回值的 任务--需要先交给任务管理对象 因为执行之后该线程是有返回值的 得有对象去处理返回值
  79.         FutureTask<Integer> task = new FutureTask<>(my);
  80.         // 在把 task对象 绑定到线程对象中
  81.         Thread thread = new Thread(task);
  82.         // 调用start方法
  83.         thread.start();
  84.        // 返回值在 Task身上
  85.         System.out.println("任务执行结果:"+task.get());
  86.  
  87.         MyCallable1 callable1 = new MyCallable1();
  88.         FutureTask<String> stringFutureTask = new FutureTask<String>(callable1);
  89.         Thread thread1 = new Thread(stringFutureTask);
  90.         thread1.start();
  91.         String s = stringFutureTask.get();
  92.         System.out.println(s);
  93.  
  94.         //这样写没意义，不能传参数，只能自己定义吗  
  95. /*        FutureTask<Integer> integerFutureTask = new FutureTask<>(new Callable<Integer>() {
  96.             int a=10;
  97.             int b=0;
  98.             @Override
  99.             public Integer call() throws Exception {
  100.                 return a+b;
  101.             }
  102.         });
  104.         new Thread(integerFutureTask).start();  //不执行线程是拿不到返回会值结果的
  105. //        new Thread(new FutureTask<Integer>(()-> 10+0 )).start(); 可以这样简写，但是拿不到结果值没意义
  106.         System.out.println(integerFutureTask.get());*/
  107.  
  108.     }
  109. }

3.Thread的常用方法

    

  1. package com.itheima.day12.teacher.thread01;
  2.  
  3. public class MyThread extends Thread{
  4.  
  5.     public MyThread(String name){
  6.         super(name);//把名字传递给父类的构造
  7.     }
  8.  
  9.     //线程任务方法 将来哪个线程对象执行 在它的代码中就可以得到哪个线程对象
  10.     @Override
  11.     public void run() {
  12.          // 干吕布
  13.         Thread thread = Thread.currentThread();//获取当前线程对象
  14.         for (int i = 1; i <=5 ; i++) {
  15.             //每人跟吕布过招 5次
  16.             System.out.println(thread.getName()+"大呼:吕布小儿,莫跑~~吃我"+i+"招!!");
  17. //            System.out.println(super.getName()+"大呼:吕布小儿,莫跑~~吃我"+i+"招!!");
  18.         }
  19.  
  20.     }
  21. }
  22.  
  23.  
  24. ----------------------
  25. package com.itheima.day12.teacher.thread01;
  26.  
  27. public class ThreadDemo {
  28.  
  29.     public static void main(String[] args) throws InterruptedException {
  30.         //三英战吕布
  31.         System.out.println("接下来请欣赏  三英战吕布！");
  32.         // 每秒钟 输出  5  4  3  2  1
  33.         for (int i = 5; i >=1 ; i--) {
  34.             System.out.println(i);
  35.             //休眠一秒
  36.             Thread.sleep(1000);
  37.         }
  38.         MyThread bb = new MyThread("刘备");
  39.         System.out.println(bb.getName());
  40.         //        bb.setName("刘备");
  41.         MyThread yy = new MyThread("关羽");
  42.  
  43.         System.out.println(yy.getName());
  44.         MyThread ff = new MyThread("张飞");
  45.         System.out.println(ff.getName());
  46.  
  47.  
  48.         bb.start();
  49.         yy.start();
  50.         ff.start();
  51.  
  52.  
  53.  
  54.     }
  55. }
  56.  
  57.  
  58. ---------------------
  59. package com.itheima.day12.teacher.thread01;
  60.  
  61. public class ThreadDemo02 {
  62.  
  63.     public static void main(String[] args) throws InterruptedException {
  64.         System.out.println("宇迪和弓箭手 一起打吕布");
  65.         //创建宇迪线程
  66.         MyThread my = new MyThread("宇迪");
  67.         my.start();//宇迪线程执行
  68.  
  69.         my.join();//先执行 当前 my线程对象 再执行其他的线程
  70.  
  71.         //同时总部 排除弓箭手也对 宇迪进行打击
  72.         Thread.currentThread().setName("弓箭手");
  73.         for (int i = 1; i <= 5; i++) {
  74.             System.out.println(Thread.currentThread().getName()+"在发射第"+i+"只箭~");
  75.         }
  76.  
  77.     }
  78. }

4.线程安全

        什么是线程安全问题？

                多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。

        线程安全问题出现的原因？

                1.存在多个线程在同时执行

                2.多个线程同时访问一个共享资源

                3.存在修改该共享资源的情况

        用程序模拟线程安全问题

  1. /**
  2. 出现的问题
  3.     两人同时取钱，卡里10万，结果都取成功，卡里-10万
  4. */
  5.  
  6.  
  7. package com.itheima.day12.teacher.asynchronize;
  8. // 先定义账户类
  9. public class Account {
  10.     private String cardId;
  11.     private double money;//余额
  12.  
  13.  
  14.     public Account() {
  15.     }
  16.  
  17.     public Account(String cardId, double money) {
  18.         this.cardId = cardId;
  19.         this.money = money;
  20.     }
  21.     /*
  22.      设计一个取钱的方法
  23.         参数   取得钱 金额
  24.         返回值  不需要
  25.      */
  26.     public void drawMoney(double money){
  27.         //  局部位置money 代表取的钱
  28.         //  成员位置money 代表余额
  29.         //  this.money -= money;
  30.         // 知道是谁来取的----哪个线程执行到这里了 谁就是哪个线程
  31.         String name = Thread.currentThread().getName();
  32.         // 判断余额是否充足
  33.         if(this.money >= money){//可以取
  34.             System.out.println(name+"来取钱:"+money+" 成功!");
  35.             this.money -= money;
  36.             System.out.println(name+"取钱之后的余额:"+this.money);
  37.         }else {
  38.             System.out.println(name+"来取钱:余额不足,请充值后再去...");
  39.         }
  40.     }
  41.  
  42.  
  43.  
  44.     /**
  45.      * 获取
  46.      * @return cardId
  47.      */
  48.     public String getCardId() {
  49.         return cardId;
  50.     }
  51.  
  52.     /**
  53.      * 设置
  54.      * @param cardId
  55.      */
  56.     public void setCardId(String cardId) {
  57.         this.cardId = cardId;
  58.     }
  59.  
  60.     /**
  61.      * 获取
  62.      * @return money
  63.      */
  64.     public double getMoney() {
  65.         return money;
  66.     }
  67.  
  68.     /**
  69.      * 设置
  70.      * @param money
  71.      */
  72.     public void setMoney(double money) {
  73.         this.money = money;
  74.     }
  75.  
  76.     @Override
  77.     public String toString() {
  78.         return "Account{cardId = " + cardId + ", money = " + money + "}";
  79.     }
  80. }
  81.  
  82.  
  83. ---------------
  84. package com.itheima.day12.teacher.asynchronize;
  85. /*
  86.   取钱线程类
  87.  */
  88. public class DrawMoney extends Thread{
  89.     // 定义一个账户的成员变量  --初始化交给了构造 由外界传递进来
  90.     private Account account;
  91.     //  构造第一个参数 是 取钱的账户对象  第二参数 表示线程的名字
  92.     public DrawMoney(Account account,String name){
  93.         super(name);
  94.         this.account = account;
  95.     }
  96.  
  97.     @Override
  98.     public void run() {
  99.         //取钱就是在账户里面 减少余额
  100.         // 调用账户对象 的 取钱方法
  101.         // 小明线程 小红线程 操作的 账户是同一个
  102.         // 在测试类创建 一个账户 传递进来
  103.         account.drawMoney(100000); // 通过账户对象 取钱 (取的钱数)
  104.     }
  105. }
  106.  
  107.  
  108. ------------------
  109. package com.itheima.day12.teacher.asynchronize;
  110.  
  111. public class ThreadTest {
  112.  
  113.     public static void main(String[] args) {
  114.         //创建一个账户对象   小明和小红 共享账户   卡号        余额
  115.         Account account = new Account("ICBC-114",100000);
  116.         //创建两个线程对象 分别代表小红 和 小明
  117.         // 线程对象中传递 共享的账户 以及 线程名字
  118.         new DrawMoney(account,"小明").start();
  119.         new DrawMoney(account,"小红").start();
  120.     }
  121. }

5.线程同步

        1.认识线程同步: 线程同步是解决线程安全问题的方案

        2.线程同步的思想:

                1.让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

                2.加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

        3.线程同步的解决方案

                方式一：同步代码块

                        作用：把访问共享资源的核心代码给上锁，以此保证线程安全。

                        原理：每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。

                        写法：

                                synchronized(同步锁) { 访问共享资源的核心代码 }

                        同步锁的注意事项:对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。

                        锁对象的使用规范:

                                建议使用共享资源作为锁对象

                                对于实例方法建议使用this作为锁对象

                                对于静态方法建议使用字节码（类名.class）对象作为锁对象

                

  1. package com.itheima.day12.teacher.synchronize01;
  2. // 先定义账户类
  3. public class Account {
  4.     private String cardId;
  5.     private double money;//余额
  6.  
  7.  
  8.     public Account() {
  9.     }
  10.  
  11.     public Account(String cardId, double money) {
  12.         this.cardId = cardId;
  13.         this.money = money;
  14.     }
  15.     /*
  16.      设计一个取钱的方法
  17.         参数   取得钱 金额
  18.         返回值  不需要
  19.      */
  20.     public void drawMoney(double money){
  21.        // 使用同步代码块方式加锁  保证两个线程只要一个线程在修改共享资源
  22.         //  锁对象怎么选择  --- 只要保证 两个线程对象将来公用一把锁
  23.         synchronized (this){ //() 里面的对象具备唯一性 "lock" 字符串一旦创建不能能改
  24.                    //直接写字符串  可以 但是不规范  开发规范当前共享资源  一般普通方法写 this  静态方法写 类名.class
  25.             //  局部位置money 代表取的钱
  26.             //  成员位置money 代表余额
  27.             //  this.money -= money;
  28.             // 知道是谁来取的----哪个线程执行到这里了 谁就是哪个线程
  29.             String name = Thread.currentThread().getName();
  30.             // 判断余额是否充足
  31.             if(this.money >= money){//可以取
  32.                 System.out.println(name+"来取钱:"+money+" 成功!");
  33.                 this.money -= money;
  34.                 System.out.println(name+"取钱之后的余额:"+this.money);
  35.             }else {
  36.                 System.out.println(name+"来取钱:余额不足,请充值后再去...");
  37.             }
  38.         }
  39.  
  40.  
  41.     }
  42.  
  43.  
  44.  
  45.     /**
  46.      * 获取
  47.      * @return cardId
  48.      */
  49.     public String getCardId() {
  50.         return cardId;
  51.     }
  52.  
  53.     /**
  54.      * 设置
  55.      * @param cardId
  56.      */
  57.     public void setCardId(String cardId) {
  58.         this.cardId = cardId;
  59.     }
  60.  
  61.     /**
  62.      * 获取
  63.      * @return money
  64.      */
  65.     public double getMoney() {
  66.         return money;
  67.     }
  68.  
  69.     /**
  70.      * 设置
  71.      * @param money
  72.      */
  73.     public void setMoney(double money) {
  74.         this.money = money;
  75.     }
  76.  
  77.     public String toString() {
  78.         return "Account{cardId = " + cardId + ", money = " + money + "}";
  79.     }
  80. }
  81.  
  82.  
  83. -----------------------
  84. package com.itheima.day12.teacher.synchronize01;
  85.  
  86. /*
  87.   取钱线程类
  88.  */
  89. public class DrawMoney extends Thread{
  90.     // 定义一个账户的成员变量  --初始化交给了构造 由外界传递进来
  91.     private Account account;
  92.     //  构造第一个参数 是 取钱的账户对象  第二参数 表示线程的名字
  93.     public DrawMoney(Account account, String name){
  94.         super(name);
  95.         this.account = account;
  96.     }
  97.  
  98.     @Override
  99.     public void run() {
  100.         //取钱就是在账户里面 减少余额
  101.         // 调用账户对象 的 取钱方法
  102.         // 小明线程 小红线程 操作的 账户是同一个
  103.         // 在测试类创建 一个账户 传递进来
  104.         account.drawMoney(100000); // 通过账户对象 取钱 (取的钱数)
  105.     }
  106. }
  107.  
  108.  
  109. ---------------------
  110. package com.itheima.day12.teacher.synchronize01;
  111.  
  112. public class ThreadTest {
  113.  
  114.     public static void main(String[] args) {
  115.         //创建一个账户对象   小明和小红 共享账户   卡号        余额
  116.         Account account = new Account("ICBC-114",100000);
  117.         //创建两个线程对象 分别代表小红 和 小明
  118.         // 线程对象中传递 共享的账户 以及 线程名字
  119.         new DrawMoney(account,"小明").start();
  120.         new DrawMoney(account,"小红").start();
  121.     }
  122. }

                方式二：同步方法

                        作用：把访问共享资源的核心方法给上锁，以此保证线程安全。

                        原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

                        写法：        

                                修饰符 synchronized 返回值类型 方法名称(形参列表) { 操作共享资源的代码 }

                        同步方法底层原理:

                                1.同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

                                2.如果方法是实例方法：同步方法默认用this作为的锁对象。

                                3.如果方法是静态方法：同步方法默认用类名.class作为的锁对象。

                是同步代码块好还是同步方法好一点？

                        范围上：同步代码块锁的范围更小，同步方法锁的范围更大。

                        可读性：同步方法更好。

                

  1. package com.itheima.day12.teacher.synchronize02;
  2. // 先定义账户类
  3. public class Account {
  4.     private String cardId;
  5.     private double money;//余额
  6.  
  7.  
  8.     public Account() {
  9.     }
  10.  
  11.     public Account(String cardId, double money) {
  12.         this.cardId = cardId;
  13.         this.money = money;
  14.     }
  15.     /*
  16.      设计一个取钱的方法
  17.         参数   取得钱 金额
  18.         返回值  不需要
  20.           同步方法
  21.              就是将锁 固定到方法上了  整个方法上锁了
  22.           方法声明位置 加入 synchronized 关键字
  23.      */
  24.     public synchronized void drawMoney(double money){
  25.             //  局部位置money 代表取的钱
  26.             //  成员位置money 代表余额
  27.             //  this.money -= money;
  28.             // 知道是谁来取的----哪个线程执行到这里了 谁就是哪个线程
  29.             String name = Thread.currentThread().getName();
  30.             // 判断余额是否充足
  31.             if(this.money >= money){//可以取
  32.                 System.out.println(name+"来取钱:"+money+" 成功!");
  33.                 this.money -= money;
  34.                 System.out.println(name+"取钱之后的余额:"+this.money);
  35.             }else {
  36.                 System.out.println(name+"来取钱:余额不足,请充值后再去...");
  37.             }
  38.  
  39.  
  40.     }
  41.  
  42.  
  43.  
  44.     /**
  45.      * 获取
  46.      * @return cardId
  47.      */
  48.     public String getCardId() {
  49.         return cardId;
  50.     }
  51.  
  52.     /**
  53.      * 设置
  54.      * @param cardId
  55.      */
  56.     public void setCardId(String cardId) {
  57.         this.cardId = cardId;
  58.     }
  59.  
  60.     /**
  61.      * 获取
  62.      * @return money
  63.      */
  64.     public double getMoney() {
  65.         return money;
  66.     }
  67.  
  68.     /**
  69.      * 设置
  70.      * @param money
  71.      */
  72.     public void setMoney(double money) {
  73.         this.money = money;
  74.     }
  75.  
  76.     public String toString() {
  77.         return "Account{cardId = " + cardId + ", money = " + money + "}";
  78.     }
  79. }
  80.  
  81.  
  82. -----------------
  83. package com.itheima.day12.teacher.synchronize02;
  84.  
  85. /*
  86.   取钱线程类
  87.  */
  88. public class DrawMoney extends Thread{
  89.     // 定义一个账户的成员变量  --初始化交给了构造 由外界传递进来
  90.     private Account account;
  91.     //  构造第一个参数 是 取钱的账户对象  第二参数 表示线程的名字
  92.     public DrawMoney(Account account, String name){
  93.         super(name);
  94.         this.account = account;
  95.     }
  96.  
  97.     @Override
  98.     public void run() {
  99.         //取钱就是在账户里面 减少余额
  100.         // 调用账户对象 的 取钱方法
  101.         // 小明线程 小红线程 操作的 账户是同一个
  102.         // 在测试类创建 一个账户 传递进来
  103.         account.drawMoney(100000); // 通过账户对象 取钱 (取的钱数)
  104.     }
  105. }
  106.  
  107.  
  108. -----------------
  109. package com.itheima.day12.teacher.synchronize02;
  110.  
  111. public class ThreadTest {
  112.  
  113.     public static void main(String[] args) {
  114.         //创建一个账户对象   小明和小红 共享账户   卡号        余额
  115.         Account account = new Account("ICBC-114",100000);
  116.         //创建两个线程对象 分别代表小红 和 小明
  117.         // 线程对象中传递 共享的账户 以及 线程名字
  118.         new DrawMoney(account,"小明").start();
  119.         new DrawMoney(account,"小红").start();
  120.     }
  121. }

                方式三：Lock锁

                        Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。

                        Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。

        

  1. package com.itheima.day12.teacher.lock;
  2.  
  3. import java.util.concurrent.locks.Lock;
  4. import java.util.concurrent.locks.ReentrantLock;
  5.  
  6. // 先定义账户类
  7. public class Account {
  8.     private String cardId;
  9.     private double money;//余额
  10.  
  11.  
  12.     public Account() {
  13.     }
  14.  
  15.     public Account(String cardId, double money) {
  16.         this.cardId = cardId;
  17.         this.money = money;
  18.     }
  19.     /*
  20.      设计一个取钱的方法
  21.         参数   取得钱 金额
  22.         返回值  不需要
  23.          Lock 都是加锁原理
  24.            底层 都是每次只允许一个线程加锁 加锁之后才能访问，手动解锁 其他线程可以再加锁进来。
  25.            灵活的加锁和释放锁
  27.            两个方法
  28.               lock() 加锁  unlock() 释放锁
  30.           Lock接口 用它的实现类
  31.      */
  32.     //成员位置创建一个 Lock锁对象 锁对象不能被改 所以 加上final修饰
  33.     private final Lock lock = new ReentrantLock();
  34.  
  35.     public  void drawMoney(double money){
  36.             //  局部位置money 代表取的钱
  37.             //  成员位置money 代表余额
  38.             //  this.money -= money;
  39.             // 知道是谁来取的----哪个线程执行到这里了 谁就是哪个线程
  40.             String name = Thread.currentThread().getName();
  41.             // 判断余额是否充足
  42.            lock.lock();//加锁
  43.             if(this.money >= money){//可以取
  44.                 System.out.println(name+"来取钱:"+money+" 成功!");
  45.                 this.money -= money;
  46.                 System.out.println(name+"取钱之后的余额:"+this.money);
  47.  
  48.             }else {
  49.                 System.out.println(name+"来取钱:余额不足,请充值后再去...");
  50.             }
  51.         lock.unlock();//释放锁
  52.  
  53.     }
  54.  
  55.  
  56.  
  57.     /**
  58.      * 获取
  59.      * @return cardId
  60.      */
  61.     public String getCardId() {
  62.         return cardId;
  63.     }
  64.  
  65.     /**
  66.      * 设置
  67.      * @param cardId
  68.      */
  69.     public void setCardId(String cardId) {
  70.         this.cardId = cardId;
  71.     }
  72.  
  73.     /**
  74.      * 获取
  75.      * @return money
  76.      */
  77.     public double getMoney() {
  78.         return money;
  79.     }
  80.  
  81.     /**
  82.      * 设置
  83.      * @param money
  84.      */
  85.     public void setMoney(double money) {
  86.         this.money = money;
  87.     }
  88.  
  89.     public String toString() {
  90.         return "Account{cardId = " + cardId + ", money = " + money + "}";
  91.     }
  92. }
  93.  
  94.  
  95. ---------------------
  96. package com.itheima.day12.teacher.lock;
  97.  
  98. /*
  99.   取钱线程类
  100.  */
  101. public class DrawMoney extends Thread{
  102.     // 定义一个账户的成员变量  --初始化交给了构造 由外界传递进来
  103.     private Account account;
  104.     //  构造第一个参数 是 取钱的账户对象  第二参数 表示线程的名字
  105.     public DrawMoney(Account account, String name){
  106.         super(name);
  107.         this.account = account;
  108.     }
  109.  
  110.     @Override
  111.     public void run() {
  112.         //取钱就是在账户里面 减少余额
  113.         // 调用账户对象 的 取钱方法
  114.         // 小明线程 小红线程 操作的 账户是同一个
  115.         // 在测试类创建 一个账户 传递进来
  116.         account.drawMoney(100000); // 通过账户对象 取钱 (取的钱数)
  117.     }
  118. }
  119.  
  120.  
  121. ---------------------
  122. package com.itheima.day12.teacher.lock;
  123.  
  124. public class ThreadTest {
  125.  
  126.     public static void main(String[] args) {
  127.         //创建一个账户对象   小明和小红 共享账户   卡号        余额
  128.         Account account = new Account("ICBC-114",100000);
  129.         //创建两个线程对象 分别代表小红 和 小明
  130.         // 线程对象中传递 共享的账户 以及 线程名字
  131.         new DrawMoney(account,"小明").start();
  132.         new DrawMoney(account,"小红").start();
  133.     }
  134. }

  6.线程通信

        1.什么是线程通信？

                当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以相互协调，并避免无效的资源争夺。

        2.线程通信的常见模型（生产者与消费者模型）

                  生产者线程负责生产数据

                  消费者线程负责消费生产者生产的数据。

                   注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产！

        3.Object类的等待和唤醒方法：

                

        注意事项:上述方法应该使用当前同步锁对象进行调用。

  1. package com.itheima.day12.teacher.wait_notify;
  2.  
  3. import java.util.ArrayList;
  4. import java.util.List;
  5.  
  6. /*
  7.    定义桌子类
  8.        定义一个存储包子的集合 存储包子
  10.        定义一个厨师生产包子的方法
  12.        定义一个吃货吃包子的方法
  13.  */
  14. public class Desk {
  15.     //  定义一个存储包子的集合 存储包子
  16.     private List<String> list = new ArrayList<>();
  17.  
  18.     // 定义一个厨师生产包子的方法
  19.     public synchronized void put()  {
  20.  
  21.         try{
  22.             //获取厨师线程对象的名称
  23.             String name = Thread.currentThread().getName();
  24.             //判断有没有包子
  25.             if(list.size()==0){//没有包子 厨师要做包子
  26.                 list.add(name+"做的包子..");//生产包子 把包子放到集合中
  27.                 System.out.println("厨师:"+name+"正在做包子.....");
  28.                 //模拟做包子的时间
  29.                 Thread.sleep(2000);
  30.                 //等待和唤醒方法 一般采用共享资源进行调用
  31.                 //包子做完了
  32.                 this.notifyAll();//唤醒所有的吃货
  33.                 this.wait();//厨师进入休息 等待
  34.             }else {
  35. //                this.notifyAll();//唤醒所有的吃货
  36.                 this.wait();//厨师进入休息 等待 因为桌子上有包子了。
  37.             }
  38.         }catch (InterruptedException e){
  39.             e.printStackTrace();
  40.         }
  41.  
  42.  
  43.     }
  44.     //定义一个 吃货 吃包子的方法
  45.     public synchronized  void get() {
  46.  
  47.         try{
  48.             //获取吃货的名称
  49.             String name = Thread.currentThread().getName();
  50.             //先判断有没有包子
  51.             if(list.size()==1){
  52.                 //模拟吃包子
  53.                 System.out.println("吃货:"+name+"正在吃"+list.get(0));
  54.                 list.clear();//清空
  55.                 Thread.sleep(1500);
  56.                 //吃饭之后
  57.                 //唤醒厨师
  58.                 this.notifyAll();
  59.                 //吃货休息
  60.                 this.wait();
  61.  
  62.             }else {
  63.                 //唤醒厨师
  64. //                this.notifyAll();
  65.                 //吃货休息
  66.                 this.wait();
  67.             }
  68.         }catch (Exception e){
  69.             e.printStackTrace();
  70.         }
  71.  
  72.     }
  73.  
  74. }
  75.  
  76.  
  77. ---------------------
  78. package com.itheima.day12.teacher.wait_notify;
  79.  
  80. public class QingFengBaoZiPu {
  81.  
  82.     public static void main(String[] args) {
  83.         //开始准备吃包子
  84.         System.out.println("进入庆丰包子铺 坐了下来 点餐");
  85.  
  86.         /*
  87.           new Thread().start() 是开启一个新的线程
  89.           new Thread(线程任务,线程名字).start()
  90.              给新的线程绑定一个线程任务和线程的名字
  93.          new Thread(()->{},线程名字).start()
  94.            因为线程任务是 函数式接口 所以可以使用 lambda去表达
  95.            ()->{
  96.                 //厨师要生产包子
  97.                 while(true){
  98.                     desk.put();
  99.                 }
  100.            }
  101.            厨师生产包子  只要包子没有了就可以去生产  所以写了一个循环
  103.            ()->{
  104.                 //吃货要次包子
  105.                 while(true){
  106.                     desk.get();
  107.                 }
  108.            }
  109.            吃货吃包子 只要包子还有 就可以吃  所以也写了一个循环
  111.          */
  112.  
  113.  
  114.         //创建共享资源
  115.         Desk desk = new Desk();
  116.  
  117.         //有三个厨师  线程
  118.         new Thread(()->{
  119.             //厨师要生产包子
  120.             while(true){
  121.                 desk.put();
  122.             }
  123.         },"霍大厨").start();
  124.         new Thread(()->{
  125.             //厨师要生产包子
  126.             while(true){
  127.                 desk.put();
  128.             }
  129.         },"雷大厨").start();
  130.         new Thread(()->{
  131.             //厨师要生产包子
  132.             while(true){
  133.                 desk.put();
  134.             }
  135.         },"卧龙凤厨").start();
  136.         //有两个吃货 线程
  137.         new Thread(()->{
  138.             //吃货要次包子
  139.             while(true){
  140.                 desk.get();
  141.             }
  142.         },"乐吃货").start();
  143.         new Thread(()->{
  144.             //吃货要次包子
  145.             while(true){
  146.                 desk.get();
  147.             }
  148.         },"李逵吃货").start();
  149.     }
  150. }

7.线程池

        1.什么是线程池？        

                线程池就是一个可以复用线程的技术。

        2.如何创建线程池？

                方式一：使用ExecutorService的实现类ThreadPoolExecutor创建一个线程池对象。

  1. package com.itheima.day12.teacher.threadpool;
  2.  
  3. public class CuoZao implements Runnable{
  4.     @Override
  5.     public void run() {
  6.         //任务是搓澡
  7.         String name = Thread.currentThread().getName();
  8.  
  9.         System.out.println("号码为:"+name+"的师傅正在给客人搓澡=====盐搓---奶搓---醋搓--");
  10.  
  11.         //模拟搓澡时间
  12.         try {
  13.             //5秒搓一个
  14.             Thread.sleep(5000);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.     }
  19. }
  20.  
  21.  
  22. --------------
  23. package com.itheima.day12.teacher.threadpool;
  24.  
  25. import java.util.concurrent.*;
  26.  
  27. public class Demo {
  28.  
  29.     public static void main(String[] args) throws InterruptedException {
  30.         // 先构建一个 线程池对象
  31.         ExecutorService pool = new ThreadPoolExecutor(
  32.                 3,//核心线程数量
  33.                 5,// 最大线程数量 = 核心线程数量+临时线程数量;
  34.                 8,//临时存活时间  时间的数量
  35.                 TimeUnit.SECONDS,// 超过核心现场后 如果有线程超过8秒中没有被使用 就销毁掉
  36.                 new ArrayBlockingQueue<>(4),//指定任务队列 任务阻塞队列  阻塞长度是4
  37.                 Executors.defaultThreadFactory(),//用户创建线程对象的工程对象 固定代码
  38.                 new ThreadPoolExecutor.CallerRunsPolicy());//任务拒绝策略 四个 我选取最后 忙不过来 找外援
  39.         // 线程池  澡堂
  40.         //  核心线程数量  老板招聘的 三个搓澡师傅
  41.         //执行搓澡任务
  42.         CuoZao cz = new CuoZao();
  43.         //来一个顾客 搓一个顾客
  44.         //接客
  45.         pool.execute(cz);//核心
  46.         pool.execute(cz);//核心
  47.         pool.execute(cz);//核心
  48.         //三个客人
  49.  
  50.         pool.execute(cz);//第四个客人 先等待了  核心线程为他服务
  51.         pool.execute(cz);//第五个客人
  52.         pool.execute(cz);//第六个客人
  53.         pool.execute(cz);//第七个客人
  54.         // 7-3 = 4
  55.  
  56.         pool.execute(cz);//第八个客人 触发了 招聘临时工  阻塞队列4 一旦超出阻塞队列 就增派人手
  57.         pool.execute(cz);//第九个客人                  阻塞队列4  超出阻塞队列两个 增派两个人手
  58.         // 第九个客人 已经有五个搓澡师傅 已经达到 最大线程数量
  59.  
  60.         pool.execute(cz);//第十个客人   阻塞队列满了 超出阻塞队列的 用两个人手  但是还少一个
  61.         // 这个时候拒绝策略 -- 增派人手  main来处理。。。
  62.  
  63.         Thread.sleep(20000);//时间过了十一秒 没有新的任务 肯定有线程没有处理任务的 这种任务就会销毁
  64.         System.out.println("至少空闲了12秒 已经有被销毁的线程了...销毁之后 ");
  65.  
  66.         pool.execute(cz);
  67.         pool.execute(cz);
  68.         pool.execute(cz);
  69.  
  70.         pool.execute(cz);
  71.         pool.execute(cz);
  72.  
  73.         pool.shutdown();//都搓完了 把 澡堂关闭
  74. //        pool.shutdownNow();//里面关闭 没搓完的任务回到队列中
  75.  
  76.          // 临时线程什么时候创建？  核心线程忙 + 任务队列满了。可以创建临时线程。
  77.         // 如果临时线程也满了，触发了拒绝策略，
  78.                         //  可能1: 找主线程帮忙处理。
  79.                         //   可能2: 抛弃 说声对不起  异常
  80.                        //    可能3: 抛弃 什么也不说
  81.                        //    可能4: 抛弃对头  放入新的
  82.     }
  83. }
  84.

submit方法:

        

  1. package com.itheima.day12.teacher.threadpool;
  2.  
  3. import java.util.concurrent.Callable;
  4.  
  5. public class Download implements Callable<String> {
  6.     @Override
  7.     public String call() throws Exception {
  8.         System.out.println(Thread.currentThread().getName()+"正在下载程序.....");
  9.         return "任务下载完成";
  10.     }
  11. }
  12.  
  13.  
  14. --------------------
  15. package com.itheima.day12.teacher.threadpool;
  16.  
  17. import java.util.concurrent.*;
  18.  
  19. public class XunLei {
  20.  
  21.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  22.         ExecutorService pool = new ThreadPoolExecutor(
  23.                 3,//核心线程数量
  24.                 5,// 最大线程数量 = 核心线程数量+临时线程数量;
  25.                 8,//临时存活时间  时间的数量
  26.                 TimeUnit.SECONDS,// 超过核心现场后 如果有线程超过8秒中没有被使用 就销毁掉
  27.                 new ArrayBlockingQueue<>(4),//指定任务队列 任务阻塞队列  阻塞长度是4
  28.                 Executors.defaultThreadFactory(),//用户创建线程对象的工程对象 固定代码
  29.                 new ThreadPoolExecutor.CallerRunsPolicy());//任务拒绝策略 四个 我选取最
  30.  
  31.             //线程池 处理 带返回值的任务
  32.         Download d = new Download();//下载任务
  33.         Future<String> f1 = pool.submit(d);
  34.         pool.submit(d);
  35.         pool.submit(d);
  36.         pool.submit(d);
  37.         pool.submit(d);
  38.  
  39.         System.out.println(f1.get());
  40.  
  41.     }
  42. }

                方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

                线程池的注意事项: 

                        1、临时线程什么时候创建？

                                新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。

                        2、什么时候会开始拒绝新任务？

                                核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

       3.使用ExecutorService线程池对象的常用方法

                        void execute(Runnable command)

        4.新任务拒绝策略

        

        5.线程池处理Callable任务

        使用ExecutorService线程池对象的常用方法---Future<T> submit(Callable<T> task)

        6.Executors工具类实现线程池

                是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。

        注意 ：这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。

        7.Executors使用可能存在的陷阱

                大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

  1. package com.itheima.day12.teacher.threadpool;
  2.  
  3. import java.util.concurrent.Callable;
  4.  
  5. public class Download implements Callable<String> {
  6.     @Override
  7.     public String call() throws Exception {
  8.         System.out.println(Thread.currentThread().getName()+"正在下载程序.....");
  9.         return "任务下载完成";
  10.     }
  11. }
  12.  
  13.  
  14. -------------------
  15. package com.itheima.day12.teacher.threadpool;
  16.  
  17. import java.util.concurrent.*;
  18.  
  19. public class XunLei2 {
  20.  
  21.     public static void main(String[] args) throws ExecutionException, InterruptedException {
  22.         ExecutorService pool = Executors.newFixedThreadPool(3);
  23.  
  24.             //线程池 处理 带返回值的任务
  25.         Download d = new Download();//下载任务
  26.         Future<String> f1 = pool.submit(d);
  27.         pool.submit(d);
  28.         pool.submit(d);
  29.         pool.submit(d);
  30.         pool.submit(d);
  31.  
  32.         System.out.println(f1.get());
  33.  
  34.     }
  35. }

8.其它细节知识：并发、并行

        1.进程:

                正在运行的程序（软件）就是一个独立的进程。

                线程是属于进程的，一个进程中可以同时运行很多个线程。

                进程中的多个线程其实是并发和并行执行的。

        2.并发的含义

                进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。

        3.并行的理解

                在同一个时刻上，同时有多个线程在被CPU调度执行。

        4.多线程是怎么执行的？

                并发和并行同时进行的

9.其它细节知识：线程的生命周期   

        1.线程的6种状态           

        

       2.线程6中状态互相转换  

          

        

                             

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号