1. 线程基本概念

程序

是为了完成特定的任务,用某种语言编写的一组指令的集合.

简单说 : 就是我们写的代码

进程

  1. 进程是指运行中的程序,比如我们使用QQ,就启动了一个进程,操作系统就会为
    该进程分配内存空间。当我们使用迅雷,又启动了一个进程,操作系统将为迅雷分
    配新的内存空间
  2. 进程是程序的一次执行过程,或是正在运行的一个程序。是动态过程:有它自身的
    产生、存在和消亡的过程

程序 —运行run—> 进程

线程

  1. 线程由进程创建的,是进程的一个实体
  2. 一个进程可以拥有多个线程

其他相关概念

  1. 单线程:同一个时刻,只允许执行一个线程
  2. 多线程:同一个时刻,可以执行多个线程,比如:一个QQ进程,可以同时打
    开多个聊天窗口,一个迅雷进程,可以同时下载多个文件
  3. 并发:同一个时刻,多个任务交替执行,造成一种“貌似同时”的错觉,简单的说
    单核cpu实现的多任务就是并发
  4. 并行:同一个时刻,多个任务同时执行。多核cpu可以实现并行。并发和并行,

2. 线程基本使用

创建线程的三种方式

在java中线程来使用有两种方法

  1. 继承 Thread类,重写run方法
  2. 实现 Runnable接口,重写run方法

第17章 多线程基础 - 图1

线程应用案例 1-继承 Thread 类

  1. 请编写程序开启一个线程,该线程毎隔1秒。在控制台输出“喵喵我是小猫咪

  2. 对上题改进:当输出80次喵喵,我是小猫咪,结束该线程

  3. 使用 JConsole 监控线程执行情况,并画岀程序示意图!
    第17章 多线程基础 - 图2

  4. 当一个类继承了 Thread 类， 该类就可以当做线程使用

  5. 我们会重写 run方法，写上自己的业务代码

  6. run Thread 类 实现了 Runnable 接口的run方法

  1.     @Override
  2.     public void run() {
  3.         if (target != null) {
  4.             target.run();
  5.         }
  6.     }
  1. public class Thread01 {
  2.     public static void main(String[] args) throws InterruptedException {
  4.         //创建Cat对象，可以当做线程使用
  5.         Cat cat = new Cat();
  7.         //老韩读源码
  8.         /*
  9.             (1)
  10.             public synchronized void start() {
  11.                 start0();
  12.             }
  13.             (2)
  14.             //start0() 是本地方法，是JVM调用, 底层是c/c++实现
  15.             //真正实现多线程的效果， 是start0(), 而不是 run
  16.             private native void start0();
  18.          */
  20.         cat.start();//启动线程-> 最终会执行cat的run方法
  24.         //cat.run();//run方法就是一个普通的方法, 没有真正的启动一个线程，就会把run方法执行完毕，才向下执行
  25.         //说明: 当main线程启动一个子线程 Thread-0, 主线程不会阻塞, 会继续执行
  26.         //这时 主线程和子线程是交替执行..
  27.         System.out.println("主线程继续执行" + Thread.currentThread().getName());//名字main
  28.         for(int i = 0; i < 60; i++) {
  29.             System.out.println("主线程 i=" + i);
  30.             //让主线程休眠
  31.             Thread.sleep(1000);
  32.         }
  34.     }
  35. }
  1. class Cat extends Thread {
  3.     int times = 0;
  4.     @Override
  5.     public void run() {//重写run方法，写上自己的业务逻辑
  7.         while (true) {
  8.             //该线程每隔1秒。在控制台输出 “喵喵, 我是小猫咪”
  9.             System.out.println("喵喵, 我是小猫咪" + (++times) + " 线程名=" + Thread.currentThread().getName());
  10.             //让该线程休眠1秒 ctrl+alt+t
  11.             try {
  12.                 Thread.sleep(1000);
  13.             } catch (InterruptedException e) {
  14.                 e.printStackTrace();
  15.             }
  16.             if(times == 80) {
  17.                 break;//当times 到80, 退出while, 这时线程也就退出..
  18.             }
  19.         }
  20.     }
  21. }

start0() 是本地方法，是JVM调用, 底层是c/c++实现真正实现多线程的效果， 是start0(), 而不是 run private native void start0();

run() 方法就是一个普通的方法, 没有真正的启动一个线程，就会把run方法执行完毕，才向下执行

第17章 多线程基础 - 图3

线程应用案例 2-实现 Runnable 接口

  1. java是单继承的,在某些情况下一个类可能已经继承了某个父类这时在用继承 Thread 类方法来创建线程显然不可能了。
  2. java设计者们提供了另外一个方式创建线程,就是通过实现 Runnable 接口来创建线程
  1. public class Thread02 {
  2.     public static void main(String[] args) {
  3.         Dog dog = new Dog();
  4.         //dog.start(); 这里不能调用start
  5.         //创建了Thread对象，把 dog对象(实现Runnable),放入Thread
  6.         Thread thread = new Thread(dog);
  7.         thread.start();
  9. //        Tiger tiger = new Tiger();//实现了 Runnable
  10. //        ThreadProxy threadProxy = new ThreadProxy(tiger);
  11. //        threadProxy.start();
  12.     }
  13. }
  15. class Animal {
  16. }
  18. class Tiger extends Animal implements Runnable {
  20.     @Override
  21.     public void run() {
  22.         System.out.println("老虎嗷嗷叫....");
  23.     }
  24. }
  26. //线程代理类 , 模拟了一个极简的Thread类
  27. class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxy
  29.     private Runnable target = null;//属性，类型是 Runnable
  31.     @Override
  32.     public void run() {
  33.         if (target != null) {
  34.             target.run();//动态绑定（运行类型Tiger）
  35.         }
  36.     }
  38.     public ThreadProxy(Runnable target) {
  39.         this.target = target;
  40.     }
  42.     public void start() {
  43.         start0();//这个方法时真正实现多线程方法
  44.     }
  46.     public void start0() {
  47.         run();
  48.     }
  49. }
  52. class Dog implements Runnable { //通过实现Runnable接口，开发线程
  54.     int count = 0;
  56.     @Override
  57.     public void run() { //普通方法
  58.         while (true) {
  59.             System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
  61.             //休眠1秒
  62.             try {
  63.                 Thread.sleep(1000);
  64.             } catch (InterruptedException e) {
  65.                 e.printStackTrace();
  66.             }
  68.             if (count == 10) {
  69.                 break;
  70.             }
  71.         }
  72.     }
  73. }

线程应用案例 3-实现 Callable和Future接口

    1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
    1. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
    1. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
    1. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
  1. public class CallableThreadTest implements Callable<Integer> {
  2.     public static void main(String[] args)  
  3.     {  
  4.         CallableThreadTest ctt = new CallableThreadTest();  
  5.         FutureTask<Integer> ft = new FutureTask<>(ctt);  
  6.         for(int i = 0;i < 100;i++)  
  7.         {  
  8.             System.out.println(Thread.currentThread().getName()+" 的循环变量i的值"+i);  
  9.             if(i==20)  
  10.             {  
  11.                 new Thread(ft,"有返回值的线程").start();  
  12.             }  
  13.         }  
  14.         try  
  15.         {  
  16.             System.out.println("子线程的返回值："+ft.get());  
  17.         } catch (InterruptedException e)  
  18.         {  
  19.             e.printStackTrace();  
  20.         } catch (ExecutionException e)  
  21.         {  
  22.             e.printStackTrace();  
  23.         }  
  25.     }
  26.     @Override  
  27.     public Integer call() throws Exception  
  28.     {  
  29.         int i = 0;  
  30.         for(;i<100;i++)  
  31.         {  
  32.             System.out.println(Thread.currentThread().getName()+" "+i);  
  33.         }  
  34.         return i;  
  35.     }  
  36. }

静态代理模式

  1. public class Thread02 {
  2.     public static void main(String[] args) {
  3.         Dog dog = new Dog();
  4.         //dog.start(); 这里不能调用start
  5.         //创建了Thread对象，把 dog对象(实现Runnable),放入Thread
  6.         Thread thread = new Thread(dog);
  7.         thread.start();
  9. //        Tiger tiger = new Tiger();//实现了 Runnable
  10. //        ThreadProxy threadProxy = new ThreadProxy(tiger);
  11. //        threadProxy.start();
  12.     }
  13. }
  15. class Animal {
  16. }
  18. class Tiger extends Animal implements Runnable {
  20.     @Override
  21.     public void run() {
  22.         System.out.println("老虎嗷嗷叫....");
  23.     }
  24. }
  26. //线程代理类 , 模拟了一个极简的Thread类
  27. class ThreadProxy implements Runnable {//你可以把Proxy类当做 ThreadProxy
  29.     private Runnable target = null;//属性，类型是 Runnable
  31.     @Override
  32.     public void run() {
  33.         if (target != null) {
  34.             target.run();//动态绑定（运行类型Tiger）
  35.         }
  36.     }
  38.     public ThreadProxy(Runnable target) {
  39.         this.target = target;
  40.     }
  42.     public void start() {
  43.         start0();//这个方法时真正实现多线程方法
  44.     }
  46.     public void start0() {
  47.         run();
  48.     }
  49. }
  52. class Dog implements Runnable { //通过实现Runnable接口，开发线程
  54.     int count = 0;
  56.     @Override
  57.     public void run() { //普通方法
  58.         while (true) {
  59.             System.out.println("小狗汪汪叫..hi" + (++count) + Thread.currentThread().getName());
  61.             //休眠1秒
  62.             try {
  63.                 Thread.sleep(1000);
  64.             } catch (InterruptedException e) {
  65.                 e.printStackTrace();
  66.             }
  68.             if (count == 10) {
  69.                 break;
  70.             }
  71.         }
  72.     }
  73. }

线程使用应用案例-多线程执行

请编写一个程序创建两个线程一个线程每隔1秒输出“hell,word”:输出10次,退出,一个线程每隔1秒输出“hi”,输出5次退出

  1. public class Thread03 {
  2.     public static void main(String[] args) {
  4.         T1 t1 = new T1();
  5.         T2 t2 = new T2();
  6.         Thread thread1 = new Thread(t1);
  7.         Thread thread2 = new Thread(t2);
  8.         thread1.start();//启动第1个线程
  9.         thread2.start();//启动第2个线程
  10.         //...
  12.     }
  13. }
  15. class T1 implements Runnable {
  17.     int count = 0;
  19.     @Override
  20.     public void run() {
  21.         while (true) {
  22.             //每隔1秒输出 “hello,world”,输出10次
  23.             System.out.println("hello,world " + (++count));
  24.             try {
  25.                 Thread.sleep(1000);
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             if(count == 60) {
  30.                 break;
  31.             }
  32.         }
  33.     }
  34. }
  36. class T2 implements Runnable {
  38.     int count = 0;
  40.     @Override
  41.     public void run() {
  42.         //每隔1秒输出 “hi”,输出5次
  43.         while (true) {
  44.             System.out.println("hi " + (++count));
  45.             try {
  46.                 Thread.sleep(1000);
  47.             } catch (InterruptedException e) {
  48.                 e.printStackTrace();
  49.             }
  50.             if(count == 50) {
  51.                 break;
  52.             }
  53.         }
  54.     }
  55. }

3. 继承 Thread vs 实现 Runnable 的区别

  1. 从java的设计来看,通过继承 Thread 或者实现 Runnable 接口来创建线程本质上没有区别从jdk帮助文档我们可以看到 Thread 类本身就实现了 Runnable 接口 start() -> start0()
  2. 实现 Runnable接口方式更加适合多个线程共享一个资源的情况,并且避免了单继承的限制,建议使用 Runnable
  3. [售票系统],编程模拟三个售票窗口售票100分别使用继承 Thread 和实现 Runnable 方式并分析有什么问题?
    1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
    1. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。

4. 线程终止

基本说明

  1. 当线程完成任务后,会自动退出

  2. 还可以通过使用变量来控制 run 方法退出的方式停止线程,即通知方式

应用案例

  1. public class ThreadExit_ {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         T t1 = new T();
  4.         t1.start();
  6.         //如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
  7.         //让t1 退出run方法，从而终止 t1线程 -> 通知方式
  9.         //让主线程休眠 10 秒，再通知 t1线程退出
  10.         System.out.println("main线程休眠10s...");
  11.         Thread.sleep(10 * 1000);
  12.         t1.setLoop(false);
  13.     }
  14. }
  16. class T extends Thread {
  17.     private int count = 0;
  18.     //设置一个控制变量
  19.     private boolean loop = true;
  20.     @Override
  21.     public void run() {
  22.         while (loop) {
  24.             try {
  25.                 Thread.sleep(50);// 让当前线程休眠50ms
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             System.out.println("T 运行中...." + (++count));
  30.         }
  32.     }
  34.     public void setLoop(boolean loop) {
  35.         this.loop = loop;
  36.     }
  37. }

5. 线程常用方法

常用方法第一组

  1. setName 设置线程名称,使之与参数name相同

  2. getName 返回该线程的名称

  3. start 使该线程开始执行;Java虚拟机底层调用该线程的 start0方法

  4. run调用线程对象run方法

  5. setPriority 更改线程的优先级

  6. getPriority 获取线程的优先级

  7. sleep 在指定的亳秒数内让当前正在执行的线程休眠(暂停执行)

  8. interrupt 中断线程

注意事项和细节

  1. start底层会创建新的线程,调用run,run就是一个简单的方法调用,不会启动新线程

  2. 线程优先级的范围

  3. interrupt ,中断线程,但并没有真正的结束线程。所以一般用于中断正在休眠线程

  4. sleep : 线程的静态方法,使当前线程休眠

应用案例

  1. public class ThreadMethod01 {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         //测试相关的方法
  4.         T t = new T();
  5.         t.setName("老韩");
  6.         t.setPriority(Thread.MIN_PRIORITY);//1
  7.         t.start();//启动子线程
  10.         //主线程打印5 hi ,然后我就中断 子线程的休眠
  11.         for(int i = 0; i < 5; i++) {
  12.             Thread.sleep(1000);
  13.             System.out.println("hi " + i);
  14.         }
  16.         System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1
  18.         t.interrupt();//当执行到这里，就会中断 t线程的休眠.
  22.     }
  23. }
  25. class T extends Thread { //自定义的线程类
  26.     @Override
  27.     public void run() {
  28.         while (true) {
  29.             for (int i = 0; i < 100; i++) {
  30.                 //Thread.currentThread().getName() 获取当前线程的名称
  31.                 System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
  32.             }
  33.             try {
  34.                 System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
  35.                 Thread.sleep(20000);//20秒
  36.             } catch (InterruptedException e) {
  37.                 //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
  38.                 //InterruptedException 是捕获到一个中断异常.
  39.                 System.out.println(Thread.currentThread().getName() + "被 interrupt了");
  40.             }
  41.         }
  42.     }
  43. }

常用方法第二组

  1. yield:线程的礼让。让出cpu,让其他线程执行,但礼
    让的时间不确定,所以也不一定礼让成功
  2. join:线程的插队。插队的线程一旦插队成功,则肯定
    先执行完插入的线程所有的任务
  1. public class ThreadMethod02 {
  2.     public static void main(String[] args) throws InterruptedException {
  4.         T2 t2 = new T2();
  5.         t2.start();
  7.         for(int i = 1; i <= 20; i++) {
  8.             Thread.sleep(1000);
  9.             System.out.println("主线程(小弟) 吃了 " + i  + " 包子");
  10.             if(i == 5) {
  11.                 System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
  12.                 //join, 线程插队
  13.                 //t2.join();// 这里相当于让t2 线程先执行完毕
  14.                 Thread.yield();//礼让，不一定成功..
  15.                 System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
  16.             }
  18.         }
  19.     }
  20. }
  22. class T2 extends Thread {
  23.     @Override
  24.     public void run() {
  25.         for (int i = 1; i <= 20; i++) {
  26.             try {
  27.                 Thread.sleep(1000);//休眠1秒
  28.             } catch (InterruptedException e) {
  29.                 e.printStackTrace();
  30.             }
  31.             System.out.println("子线程(老大) 吃了 " + i +  " 包子");
  32.         }
  33.     }
  34. }

用户线程和守护线程

  1. 用户线程:也叫工作线程,当线程的任务执行完或通知方式结束
  2. 守护线程:一般是为工作线程服务的,当所有的用户线程结束,守护线程自动结束 myDaemonThread.setDaemon(true);
  3. 常见的守护线程:垃圾回收机制

应用案例

  1. public class ThreadMethod03 {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         MyDaemonThread myDaemonThread = new MyDaemonThread();
  4.         //如果我们希望当main线程结束后，子线程自动结束
  5.         //,只需将子线程设为守护线程即可
  6.         myDaemonThread.setDaemon(true);
  7.         myDaemonThread.start();
  9.         for( int i = 1; i <= 10; i++) {//main线程
  10.             System.out.println("宝强在辛苦的工作...");
  11.             Thread.sleep(1000);
  12.         }
  13.     }
  14. }
  16. class MyDaemonThread extends Thread {
  17.     public void run() {
  18.         for (; ; ) {//无限循环
  19.             try {
  20.                 Thread.sleep(1000);//休眠1000毫秒
  21.             } catch (InterruptedException e) {
  22.                 e.printStackTrace();
  23.             }
  24.             System.out.println("马蓉和宋喆快乐聊天，哈哈哈~~~");
  25.         }
  26.     }
  27. }

6. 线程的生命周期

JDK 中用 Thread.State 枚举表示了线程的几种状态

第17章 多线程基础 - 图4

线程状态转换图

第17章 多线程基础 - 图5

查看线程状态

  1. public class ThreadState_ {
  2.     public static void main(String[] args) throws InterruptedException {
  3.         T t = new T();
  4.         System.out.println(t.getName() + " 状态 " + t.getState());
  5.         t.start();
  7.         while (Thread.State.TERMINATED != t.getState()) {
  8.             System.out.println(t.getName() + " 状态 " + t.getState());
  9.             Thread.sleep(500);
  10.         }
  12.         System.out.println(t.getName() + " 状态 " + t.getState());
  14.     }
  15. }
  17. class T extends Thread {
  18.     @Override
  19.     public void run() {
  20.         while (true) {
  21.             for (int i = 0; i < 10; i++) {
  22.                 System.out.println("hi " + i);
  23.                 try {
  24.                     Thread.sleep(1000);
  25.                 } catch (InterruptedException e) {
  26.                     e.printStackTrace();
  27.                 }
  28.             }
  29.             break;
  30.         }
  31.     }
  32. }

7. 线程的同步

线程同步机制

  1. 在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术,保证数据在任何同一时刻,最多有一个线程访问,以保证数据的完整性。
  2. 也可以这里理解:线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作

同步具体方法-Synchronized

  1. 同步代码块
    1. synchronized(对象){
    2.  //得到对象的锁,才能操作同步代码
    3.  //需要被同步代码;
    4. }
  1. synchronized还可以放在方法声明中,表示整个方法-为同步方法
  1. public synchronized void m(String name){
  2.   //需要被同步的代码
  3. }

  1. 如何理解:
    就好像某小伙伴上厕所前先把门关上(上锁)完事后再出来
    解锁),那么其它小伙伴就可在使用厕所了

  2. 使用 synchronized解决售票问题

分析同步原理

第17章 多线程基础 - 图6

8. 互斥锁

基本介绍

  1. Java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性
  2. 每个对象都对应于一个可称为 “互斥锁” 的标记,这个标记用来保证在任一时刻,只能有一个线程访问该对象
  3. 关键字 synchronized来与对象的互斥锁联系。当某个对象用 synchronized 修饰时 ,表明该对象在任一时刻只能由一个线程访问
  4. 同步的局限性 : 导致程序的执行效率要降低
  5. 同步方法 ( 非静态的 ) 的锁可以是this,也可以是其他对象 ( 要求是同一个对象 )
  6. 同步方法 ( 静态的 ) 的锁为当前类本身。

使用互斥锁来解决售票问题

  1. public class SellTicket {
  2.     public static void main(String[] args) {
  4.             //测试
  5. //        SellTicket01 sellTicket01 = new SellTicket01();
  6. //        SellTicket01 sellTicket02 = new SellTicket01();
  7. //        SellTicket01 sellTicket03 = new SellTicket01();
  8. //
  9. //        //这里我们会出现超卖..
  10. //        sellTicket01.start();//启动售票线程
  11. //        sellTicket02.start();//启动售票线程
  12. //        sellTicket03.start();//启动售票线程
  15. //        System.out.println("===使用实现接口方式来售票=====");
  16. //        SellTicket02 sellTicket02 = new SellTicket02();
  17. //
  18. //        new Thread(sellTicket02).start();//第1个线程-窗口
  19. //        new Thread(sellTicket02).start();//第2个线程-窗口
  20. //        new Thread(sellTicket02).start();//第3个线程-窗口
  22.         //测试一把
  23.         SellTicket03 sellTicket03 = new SellTicket03();
  24.         new Thread(sellTicket03).start();//第1个线程-窗口
  25.         new Thread(sellTicket03).start();//第2个线程-窗口
  26.         new Thread(sellTicket03).start();//第3个线程-窗口
  28.     }
  29. }
  32. //实现接口方式, 使用synchronized实现线程同步
  33. class SellTicket03 implements Runnable {
  34.     private int ticketNum = 100;//让多个线程共享 ticketNum
  35.     private boolean loop = true;//控制run方法变量
  36.     Object object = new Object();
  39.     //同步方法（静态的）的锁为当前类本身
  40.     //老韩解读
  41.     //1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
  42.     //2. 如果在静态方法中，实现一个同步代码块.
  43.     /*
  44.         synchronized (SellTicket03.class) {
  45.             System.out.println("m2");
  46.         }
  47.      */
  48.     public synchronized static void m1() {
  50.     }
  51.     public static  void m2() {
  52.         synchronized (SellTicket03.class) {
  53.             System.out.println("m2");
  54.         }
  55.     }
  57.     //老韩说明
  58.     //1. public synchronized void sell() {} 就是一个同步方法
  59.     //2. 这时锁在 this对象
  60.     //3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
  61.     public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法
  63.         synchronized (/*this*/ object) {
  64.             if (ticketNum <= 0) {
  65.                 System.out.println("售票结束...");
  66.                 loop = false;
  67.                 return;
  68.             }
  70.             //休眠50毫秒, 模拟
  71.             try {
  72.                 Thread.sleep(50);
  73.             } catch (InterruptedException e) {
  74.                 e.printStackTrace();
  75.             }
  77.             System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
  78.                     + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
  79.         }
  80.     }
  82.     @Override
  83.     public void run() {
  84.         while (loop) {
  86.             sell();//sell方法是一共同步方法
  87.         }
  88.     }
  89. }
  91. //使用Thread方式
  92. // new SellTicket01().start()
  93. // new SellTicket01().start();
  94. class SellTicket01 extends Thread {
  96.     private static int ticketNum = 100;//让多个线程共享 ticketNum
  98. //    public void m1() {
  99. //        synchronized (this) {
  100. //            System.out.println("hello");
  101. //        }
  102. //    }
  104.     @Override
  105.     public void run() {
  108.         while (true) {
  110.             if (ticketNum <= 0) {
  111.                 System.out.println("售票结束...");
  112.                 break;
  113.             }
  115.             //休眠50毫秒, 模拟
  116.             try {
  117.                 Thread.sleep(50);
  118.             } catch (InterruptedException e) {
  119.                 e.printStackTrace();
  120.             }
  122.             System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
  123.                     + " 剩余票数=" + (--ticketNum));
  125.         }
  126.     }
  127. }
  130. //实现接口方式
  131. class SellTicket02 implements Runnable {
  132.     private int ticketNum = 100;//让多个线程共享 ticketNum
  134.     @Override
  135.     public void run() {
  136.         while (true) {
  138.             if (ticketNum <= 0) {
  139.                 System.out.println("售票结束...");
  140.                 break;
  141.             }
  143.             //休眠50毫秒, 模拟
  144.             try {
  145.                 Thread.sleep(50);
  146.             } catch (InterruptedException e) {
  147.                 e.printStackTrace();
  148.             }
  150.             System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
  151.                     + " 剩余票数=" + (--ticketNum));//1 - 0 - -1  - -2
  153.         }
  154.     }
  155. }

注意事项和细节

  1. 同步方法如果没有使用 static修饰:默认锁对象为this
  2. 如果方法使用 static修饰,默认锁对象当前类cass

  3. 实现的落地步骤:

    • 需要先分析上锁的代码
    • 选择同步代码块或同步方法
    • 要求多个线程的锁对象为同一个即可!

9. 线程的死锁

基本介绍

多个线程都占用了对方的锁资源,但不肯相让,导致了死锁在编程是一定要避免死锁的发生

应用案例

  1. public class DeadLock_ {
  2.     public static void main(String[] args) {
  3.         //模拟死锁现象
  4.         DeadLockDemo A = new DeadLockDemo(true);
  5.         A.setName("A线程");
  6.         DeadLockDemo B = new DeadLockDemo(false);
  7.         B.setName("B线程");
  8.         A.start();
  9.         B.start();
  10.     }
  11. }
  14. //线程
  15. class DeadLockDemo extends Thread {
  16.     static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
  17.     static Object o2 = new Object();
  18.     boolean flag;
  20.     public DeadLockDemo(boolean flag) {//构造器
  21.         this.flag = flag;
  22.     }
  24.     @Override
  25.     public void run() {
  27.         //下面业务逻辑的分析
  28.         //1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
  29.         //2. 如果线程A 得不到 o2 对象锁，就会Blocked
  30.         //3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
  31.         //4. 如果线程B 得不到 o1 对象锁，就会Blocked
  32.         if (flag) {
  33.             synchronized (o1) {//对象互斥锁, 下面就是同步代码
  34.                 System.out.println(Thread.currentThread().getName() + " 进入1");
  35.                 synchronized (o2) { // 这里获得li对象的监视权
  36.                     System.out.println(Thread.currentThread().getName() + " 进入2");
  37.                 }
  39.             }
  40.         } else {
  41.             synchronized (o2) {
  42.                 System.out.println(Thread.currentThread().getName() + " 进入3");
  43.                 synchronized (o1) { // 这里获得li对象的监视权
  44.                     System.out.println(Thread.currentThread().getName() + " 进入4");
  45.                 }
  46.             }
  47.         }
  48.     }
  49. }

10. 释放锁

下面操作会释放锁

  1. 当前线程的同步方法、同步代码块执行结束
    案例:上厕所,完事出来
  2. 当前线程在同步代码块、同步方法中遇到 break、 return
    案例:没有正常的完事,经理叫他修改bug,不得已出来
  3. 当前线程在同步代码块、同步方法中出现了未处理的Eror或 Exception,导致异常结束
    案例:没有正常的完事,发现忘带纸,不得已出来
  4. 当前线程在同步代码块、同步方法中执行了线程对象的wait0方法,当前线程暂停,并释
    案例:没有正常完事,觉得需要酝酿下,所以出来等会再进去

下面操作不会释放锁

  1. 线程执行同步代码块或同步方法时,程序调用 Thread. sleep()、 Thread yield() 方法暂停当前线程的执行,不会释放锁
    案例:上厕所,太困了,在坑位上眯了一会
  2. 线程执行同步代码块时,其他线程调用了该线程的 suspend 方法将该线程挂起,该线程不会释放锁
    提示 : 应尽量避兔使用 suspend() 和 resume() 来控制线程,方法不再推荐使用

11. 作业

第17章 多线程基础 - 图7

  1. public class Homework01 {
  2.     public static void main(String[] args) {
  3.         A a = new A();
  4.         B b = new B(a);//一定要注意.
  5.         a.start();
  6.         b.start();
  7.     }
  8. }
  10. //创建A线程类
  11. class A extends Thread {
  12.     private boolean loop = true;
  14.     @Override
  15.     public void run() {
  16.         //输出1-100数字
  17.         while (loop) {
  18.             System.out.println((int)(Math.random() * 100 + 1));
  19.             //休眠
  20.             try {
  21.                 Thread.sleep(1000);
  22.             } catch (InterruptedException e) {
  23.                 e.printStackTrace();
  24.             }
  25.         }
  26.         System.out.println("a线程退出...");
  28.     }
  30.     public void setLoop(boolean loop) {//可以修改loop变量
  31.         this.loop = loop;
  32.     }
  33. }
  35. //直到第2个线程从键盘读取了“Q”命令
  36. class B extends Thread {
  37.     private A a;
  38.     private Scanner scanner = new Scanner(System.in);
  40.     public B(A a) {//构造器中，直接传入A类对象
  41.         this.a = a;
  42.     }
  44.     @Override
  45.     public void run() {
  46.         while (true) {
  47.             //接收到用户的输入
  48.             System.out.println("请输入你指令(Q)表示退出:");
  49.             char key = scanner.next().toUpperCase().charAt(0);
  50.             if(key == 'Q') {
  51.                 //以通知的方式结束a线程
  52.                 a.setLoop(false);
  53.                 System.out.println("b线程退出.");
  54.                 break;
  55.             }
  56.         }
  57.     }
  58. }

第17章 多线程基础 - 图8

  1. public class Homework02 {
  2.     public static void main(String[] args) {
  3.         T t = new T();
  4.         Thread thread1 = new Thread(t);
  5.         thread1.setName("t1");
  6.         Thread thread2 = new Thread(t);
  7.         thread2.setName("t2");
  8.         thread1.start();
  9.         thread2.start();
  10.     }
  11. }
  13. //编程取款的线程
  14. //1.因为这里涉及到多个线程共享资源，所以我们使用实现Runnable方式
  15. //2. 每次取出 1000
  16. class T implements  Runnable {
  17.     private int money = 10000;
  19.     @Override
  20.     public void run() {
  21.         while (true) {
  23.             //解读
  24.             //1. 这里使用 synchronized 实现了线程同步
  25.             //2. 当多个线程执行到这里时，就会去争夺 this对象锁
  26.             //3. 哪个线程争夺到(获取)this对象锁，就执行 synchronized 代码块, 执行完后，会释放this对象锁
  27.             //4. 争夺不到this对象锁，就blocked ，准备继续争夺
  28.             //5. this对象锁是非公平锁.
  30.             synchronized (this) {//
  31.                 //判断余额是否够
  32.                 if (money < 1000) {
  33.                     System.out.println("余额不足");
  34.                     break;
  35.                 }
  37.                 money -= 1000;
  38.                 System.out.println(Thread.currentThread().getName() + " 取出了1000 当前余额=" + money);
  39.             }
  41.             //休眠1s
  42.             try {
  43.                 Thread.sleep(1000);
  44.             } catch (InterruptedException e) {
  45.                 e.printStackTrace();
  46.             }
  47.         }
  48.     }
  49. }