多线程

概述

进程是程序执行的最小单位，线程是进程的一部分，即一个进程对应多个线程，一个进程也可以启动多个线程。对于Java程序来说，当在DOS命令窗口输入：java HelloWorld 回车之后，会先启动JVM进程，JVM再启动一个主线程调用main()方法，同时再启动一个GC线程回收垃圾。因此整个操作是多线程。使用多线程之后，main方法结束了，JVM也不一定结束。详见下图：多线程 - 图1
JVM内存模型中，堆和方法区是多线程共享的，栈是各线程相互独立的。为什么栈是私有的？因为一个栈对应一个线程，线程之间执行各自任务，互不干扰，多线程并发是为了提高系统效率。
单核CPU能做到真正的多线程并发吗？不能。但是给人的感觉是能，就像电影院胶卷播放电影。
分析以下代码，总共指向了几个线程？（除了GC）

  1. package thread;
  3. public class ThreadTest01 {
  4.     public static void main(String[] args) {
  5.         System.out.println("main begin...");
  6.         m1();
  7.         System.out.println("main finish...");
  8.     }
  10.     private static void m1() {
  11.         System.out.println("m1 begin...");
  12.         m2();
  13.         System.out.println("m1 finish...");
  14.     }
  16.     private static void m2() {
  17.         System.out.println("m2 begin...");
  18.         m3();
  19.         System.out.println("m2 finish...");
  20.     }
  22.     private static void m3() {
  23.         System.out.println("m3...");
  24.     }
  25. }
  27. 输出：
  28. main begin...
  29. m1 begin...
  30. m2 begin...
  31. m3...
  32. m2 finish...
  33. m1 finish...
  34. main finish...
  35. //事实上只有一个，即main线程。以上方法都是在main线程中完成的。

线程实现的几种方式★★

方式一：继承Thread类，并重写run方法

  1. package com.simon;
  3. /**
  4.  * 实现多线程的方式一：继承Thread类，并重写run方法
  5.  */
  6. public class ThreadAcheive01 {
  7.     public static void main(String[] args) {
  8.         //这是一个main方法，这里的代码属于主线程，在主栈中执行。
  9.         //新建一个分支线程的对象
  10.         MyThread mt = new MyThread();
  11.         //启动线程
  12. /**
  13.  * start()方法的作用是：启动一个分支线程，在JVM中开辟一个新的栈空间，
  14.  * 这段代码任务完成之后，瞬间就结束了，这段代码的任务只是为了开辟一个新的栈空间,
  15.  * 只要新的栈空间开出来，start()方法就结束了，线程就启动成功了。
  16.  * 启动成功的线程会自动调用run方法，并且run方法在分支栈的栈底部（压栈）
  17.  * run方法在分支栈的栈底部，main方法在主栈的栈底部，run和main是平级的。
  18.  * 如果将mt.run()代替mt.start()，系统是不会启动线程的，也不会分配新的分支栈，
  19.  * 不能并发，本质上是单线程.方法体中代码执行顺序，总是自上而下的。
  20.  * 是先启动分支栈，然后主线程再执行循环语句
  21.  */
  22.         mt.start();
  23.         for (int i = 0; i < 10; i++) {
  24.             System.out.println("主线程--->" + i);
  25.         }
  26.     }
  27. }
  29. class MyThread extends Thread{
  30.     @Override
  31.     public void run() {
  32.         //编写程序，这段程序运行在分支线程中(分支栈)
  33.         for (int i = 0; i < 10; i++) {
  34.             System.out.println("分支线程--->" + i);
  35.         }
  36.     }
  37. }
  39. //输出如下：
  40. // 主线程--->0
  41. //分支线程--->0
  42. //主线程--->1
  43. //分支线程--->1
  44. //主线程--->2
  45. //分支线程--->2
  46. //主线程--->3
  47. //分支线程--->3
  48. //分支线程--->4
  49. //主线程--->4
  50. //分支线程--->5
  51. //主线程--->5
  52. //分支线程--->6
  53. //分支线程--->7
  54. //分支线程--->8
  55. //分支线程--->9
  56. //主线程--->6
  57. //主线程--->7
  58. //主线程--->8
  59. //主线程--->9

一幅图来区别run和start方法

多线程 - 图2多线程 - 图3

方式二：编写一个类实现Runnable接口

  1. package thread;
  3. /**
  4.  * 实现编程的第二种方式，编写一个类实现java.lang.Runnable接口
  5.  */
  6. public class ThreadAcheive02 {
  7.     public static void main(String[] args) {
  8.         //创建一个可运行对象
  9.         MyRunnable mr = new MyRunnable();
  10.         //将可运行对象封装成一个线程对象
  11.         //注意，有一个Thread类的构造方法就是这样，参数是一个可运行对象
  12.         Thread t = new Thread(mr);
  13.         //启动线程
  14.         t.start();
  16.         for (int i = 0; i < 10; i++) {
  17.             System.out.println("主线程--->" + i);
  18.         }
  19.     }
  20. }
  22. //这并不是一个线程类，而是一个可运行类，它不是一个线程
  23. class MyRunnable implements Runnable{
  24.     @Override
  25.     public void run() {
  26.         for (int i = 0; i < 10; i++) {
  27.             System.out.println("分支线程--->" + i);
  28.         }
  29.     }
  30. }
  32. //输出如下：
  33. // 主线程--->0
  34. //分支线程--->0
  35. //主线程--->1
  36. //分支线程--->1
  37. //分支线程--->2
  38. //主线程--->2
  39. //分支线程--->3
  40. //主线程--->3
  41. //分支线程--->4
  42. //主线程--->4
  43. //分支线程--->5
  44. //主线程--->5
  45. //分支线程--->6
  46. //主线程--->6
  47. //分支线程--->7
  48. //主线程--->7
  49. //分支线程--->8
  50. //主线程--->8
  51. //分支线程--->9
  52. //主线程--->9

方式二相对于方式一其实更好，在实现Runnable接口的基础上还可以继承，一句话：面向接口编程。所以，既然面向接口编程，那么可以采取匿名内部类的方式去实现：

方式二的改进：匿名内部类

  1. package thread;
  3. /**
  4.  * 方式二采用匿名内部类
  5.  */
  6. public class ThreadAcheiveTest2_Improve {
  7.     public static void main(String[] args) {
  8.         //接口是不能new对象的，但是这里，Runnable不再是接口，而是一个匿名内部类，所以可以new
  9.         Thread t = new Thread(new Runnable() {
  10.             @Override
  11.             public void run() {
  12.                 for (int i = 0; i < 10; i++) {
  13.                     System.out.println("分支线程-->" + (i + 1));
  14.                 }
  15.             }
  16.         });
  17.         t.start();
  18.         for (int i = 0; i < 10; i++) {
  19.             System.out.println("主线程-->" + (i + 1));
  20.         }
  21.     }
  22. }
  24. //输出如下：
  25. // 主线程-->1
  26. //主线程-->2
  27. //主线程-->3
  28. //分支线程-->1
  29. //主线程-->4
  30. //主线程-->5
  31. //主线程-->6
  32. //分支线程-->2
  33. //分支线程-->3
  34. //主线程-->7
  35. //分支线程-->4
  36. //主线程-->8
  37. //主线程-->9
  38. //分支线程-->5
  39. //主线程-->10
  40. //分支线程-->6
  41. //分支线程-->7
  42. //分支线程-->8
  43. //分支线程-->9
  44. //分支线程-->10

方式三：实现Callable接口

  1. package thread;
  3. import java.util.concurrent.Callable;
  4. import java.util.concurrent.ExecutionException;
  5. import java.util.concurrent.FutureTask;
  6. //java.util.concurrent就是我们常说的JUC，属于Java的并发包，老jdk没有这个包，是jdk的新特性
  7. /**
  8.  * 实现线程的第三种方式：实现Callable接口(jdk8新特性)
  9.  * 这种方式实现的线程可以获取线程的返回值。
  10.  * 场景：系统委派一个线程去执行一个任务，该线程执行完任务之后，可能会有一个执行结果，
  11.  * 这种情况下最好实现Callable接口
  12.  */
  13. public class ThreadAcheiveTest03 {
  14.     public static void main(String[] args) {
  15.         //创建一个“未来任务类”对象。
  16.         // Callable是一个接口，可用匿名内部类，call方法相当于run方法,只不过有返回值
  17.         FutureTask task = new FutureTask(new Callable() {
  18.             @Override
  19.             public Object call() throws Exception {
  20.                 //线程执行一个任务，执行之后可能会有一个结果，以下模拟执行
  21.                 System.out.println("call method begin..");
  22.                 Thread.sleep(1000*5);
  23.                 System.out.println("call method ends..");
  24.                 int a=10,b=20;
  25.                 return a+b; //自动装箱（基本数据类型变为引用数据类型）
  26.             }
  27.         });
  29.         //创建线程对象
  30.         Thread t = new Thread(task);
  31.         //启动线程
  32.         t.start();
  34.         //在main方法即主线程中，如何获得t线程的返回结果？
  35.         try {
  36.             //这行代码会让主线程受阻么？
  37.             //main方法想要执行必须等待get方法的结束，而get方法是为了拿到另一个线程的执行结果
  38.             //这一行代码肯定是在call方法执行完并且有返回值以后才执行，所以main线程要受阻
  39.             Object obj = task.get();
  40.             System.out.println("线程执行结果：" + obj);
  41.         } catch (InterruptedException e) {
  42.             e.printStackTrace();
  43.         } catch (ExecutionException e) {
  44.             e.printStackTrace();
  45.         }
  46.         System.out.println("hello,world");
  47.     }
  48. }
  49. //内容输出：
  50. //call method begin..
  51. //call method ends..
  52. //线程执行结果：30
  53. //hello,world
  54. //优缺点：
  55. //优点：可获得线程的执行结果     
  56. //缺点：执行效率低--在获取t线程执行结果时受阻。其实优缺点都讲的返回结果的问题。

线程的生命周期

线程的生命周期包括：新建、就绪、运行、阻塞和死亡五个时期。其中，在代码中能体现的是，就绪调用start方法，运行时调用run方法，阻塞是放弃CPU执行权(这个不算)，死亡是run方法执行结束。
image.png

关于线程的几个方法

  1. package thread;
  3. /**
  4.  * 三个内容：
  5.  * 1、怎么获取当前线程的对象    static Thread currentThread();
  6.  * 2、获取线程对象的名字    String name = 线程对象.getName();
  7.  * 3、修改线程对象的名字    线程对象.setName("线程名字");
  8.  * 4、当线程没有设置名字的时候，默认名字的规律是：Thread-0、Thread-1、Thread-2...
  9.  */
  10. public class ThreadTest02 {
  11.     public static void main(String[] args) {
  12.         System.out.println(Thread.currentThread().getName());    //main
  13.         MyThread2 mt2 = new MyThread2();
  14.         //若没有设置线程名字，则默认为：Thread-0
  15.         mt2.setName("设置当前线程名字为：分支线程A");
  16.         String mt2Name = mt2.getName();
  17.         System.out.println(mt2Name);
  18.         mt2.start();
  19.         for (int i = 0; i < 10; i++) {
  20.             System.out.println("主线程-->" + (i + 1));
  21.         }
  22.     }
  23. }
  25. class MyThread2 extends Thread{
  26.     @Override
  27.     public void run() {
  28.         for (int i = 0; i < 10; i++) {
  29.             System.out.println("分支线程--->" + (i + 1));
  30.         }
  31.     }
  32. }
  34. //输出内容如下：
  35. //设置当前线程名字为：分支线程A
  36. //主线程-->1
  37. //主线程-->2
  38. //主线程-->3
  39. //主线程-->4
  40. //主线程-->5
  41. //主线程-->6
  42. //分支线程--->1
  43. //主线程-->7
  44. //分支线程--->2
  45. //主线程-->8
  46. //分支线程--->3
  47. //主线程-->9
  48. //分支线程--->4
  49. //主线程-->10
  50. //分支线程--->5
  51. //分支线程--->6
  52. //分支线程--->7
  53. //分支线程--->8
  54. //分支线程--->9
  55. //分支线程--->10
  1. package thread;
  3. /**
  4.  * 关于线程的sleep方法：
  5.  * static void sleep(long mills)
  6.  * 1、静态方法
  7.  * 2、参数是毫秒
  8.  * 3、作用：让当前线程进入休眠即阻塞状态，放弃CPU执行权给其他线程使用.
  9.  * 4、每隔多久执行一次某些代码
  10.  */
  11. public class ThreadTest03 {
  12.     //让当前线程休眠
  13.     public static void main(String[] args) {
  14.         try {
  15.             Thread.sleep(1000*3);
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.         System.out.println("hello,Thread sleep method...");
  20.     }
  21. }
  1. package thread;
  3. /**
  4.  * 关于Thread.sleep()方法的面试题
  5.  */
  6. public class ThreadTest04 {
  7.     public static void main(String[] args) throws InterruptedException {
  8.         Thread t = new MyThread4();
  9.         t.setName("t");
  10.         t.start();
  12.         //调用sleep方法
  13.         //问题：这行代码会让线程t进入休眠状态吗？
  14.         //并不会，因为在执行的时候还是会转成：Thread.sleep(1000*5);
  15.         //这行代码的作用是，让当前线程进入休眠，也就是说main线程进入休眠
  16.         //这种感觉和下面这个Test类的情形有点像
  17.         t.sleep(1000*3);
  18.         //3秒之后才会输出
  19.         System.out.println("hello,world");
  20.     }
  21. }
  22. class MyThread4 extends Thread{
  23.     @Override
  24.     public void run() {
  25.         for (int i = 0; i < 10; i++) {
  26.             System.out.println(Thread.currentThread().getName() + "-->" + (i + 1));
  27.         }
  28.     }
  29. }
  30. //输出：
  31. //t-->1
  32. //t-->2
  33. //t-->3
  34. //t-->4
  35. //t-->5
  36. //t-->6
  37. //t-->7
  38. //t-->8
  39. //t-->9
  40. //t-->10
  41. //hello,world
  1. package demo2;
  3. public class Test {
  5.     public static void main(String[] args) {
  6.         Test.doSome();  //do some
  7.         Test test = new Test();
  8.         test.doSome();  //do some
  9.         test = null;
  10.         test.doSome();  //do some，并没有出现空指针异常
  11.     }
  13.     public static void doSome(){
  14.         System.out.println("do some");
  15.     }
  16. }
  1. package thread;
  3. /**
  4.  * sleep睡眠太久了，如果希望半道上醒来，该怎么办？
  5.  * 也就是说，如何叫醒正在睡眠的线程？
  6.  */
  7. public class ThreadTest05 {
  8.     public static void main(String[] args) {
  9.         Thread t = new Thread(new MyRunnable2());
  10.         t.setName("t");
  11.         t.start();
  13.         //希望5秒之后醒来
  14.         try {
  15.             Thread.sleep(5000);
  16.         } catch (InterruptedException e) {
  17.             e.printStackTrace();
  18.         }
  19.         //一盆冷水泼过来
  20.         //本质上是让MyRunnable2的run方法的try语句块出现异常，异常机制
  21.         t.interrupt();
  22.     }
  23. }
  24. class MyRunnable2 implements Runnable{
  26.     @Override
  27.     public void run() {
  28.         System.out.println(Thread.currentThread().getName() + "--->begin");
  29.         try {
  30.     //这里sleep为什么只能try catch...？因为run方法在父类中没有抛出任何异常，子类异常不能更多
  31.             Thread.sleep(1000*60*60*24*365);
  32.         } catch (InterruptedException e) {
  33.             e.printStackTrace();
  34.         }
  35.         System.out.println(Thread.currentThread().getName() + "--->end");
  36.     }
  37. }
  38. //输出内容如下：
  39. //t--->begin
  40. //java.lang.InterruptedException: sleep interrupted
  41. //    at java.lang.Thread.sleep(Native Method)
  42. //    at thread.MyRunnable2.run(ThreadTest05.java:31)
  43. //    at java.lang.Thread.run(Thread.java:748)
  44. //t--->end
  1. package thread;
  3. /**
  4.  * 在Java中如何强行终止一个线程的执行？
  5.  * 缺点是什么？？容易损坏数据
  6.  */
  7. public class ThreadTest06 {
  8.     public static void main(String[] args) {
  9.         Thread t = new Thread(new MyRunnable3());
  10.         t.setName("t");
  11.         t.start();
  13.         try {
  14.             Thread.sleep(1000*5);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.         t.stop();
  19.     }
  20. }
  21. class MyRunnable3 implements Runnable{
  22.     @Override
  23.     public void run() {
  24.         for (int i = 0; i < 10; i++) {
  25.             System.out.println(Thread.currentThread().getName() + "-->"+ (i+1));
  26.             try {
  27.                 Thread.sleep(1000);
  28.             } catch (InterruptedException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  32.     }
  33. }
  35. //输出如下：
  36. //t-->1
  37. //t-->2
  38. //t-->3
  39. //t-->4
  40. //t-->5
  1. package com.simon;
  3. /**
  4.  * 如何合理终止一个线程的执行？ 改标志位！
  5.  */
  6. public class ThreadTest07 {
  7.     public static void main(String[] args) {
  8.         MyRunnable4 mr = new MyRunnable4();
  9.         Thread t = new Thread(mr);
  10.         t.setName("t");
  11.         t.start();
  13.         try {
  14.             Thread.sleep(1000*3);
  15.         } catch (InterruptedException e) {
  16.             e.printStackTrace();
  17.         }
  18.         mr.run =false;
  19.     }
  20. }
  21. class MyRunnable4 implements Runnable{
  22.     boolean run = true;
  23.     @Override
  24.     public void run() {
  25.         for (int i = 0; i < 10; i++) {
  26.             if (run){
  27.                 System.out.println(Thread.currentThread().getName() + "-->"+ (i+1));
  28.                 try {
  29.                     Thread.sleep(1000);
  30.                 } catch (InterruptedException e) {
  31.                     e.printStackTrace();
  32.                 }
  33.             }else {
  34.                 //在结束之前有什么善后工作要做的，都在return之前做完，就能保证数据不丢失
  35.                 return;
  36.             }
  37.         }
  38.     }
  39. }
  40. //输出结果如下：
  41. //t-->1
  42. //t-->2
  43. //t-->3
  1. package mythread;
  3. public class ThreadTest02 {
  4.     public static void main(String[] args) {
  5.         Thread t = new Thread(new MyRunnable());
  6.         t.start();
  7.         for (int i = 0; i < 10000; i++) {
  8.             System.out.println(Thread.currentThread().getName() + ":" + i);
  9.         }
  10.     }
  11. }
  12. class MyRunnable implements Runnable{
  13.     @Override
  14.     public void run() {
  15.         for (int i = 0; i < 10000; i++) {
  16.             if (i%1000==0){
  17.          //每隔1000，即当999-->1000，3999-->4000时，两者都不会连续而是硬生生让给了main线程
  18.                 Thread.yield();
  19.             }
  20.             System.out.println(Thread.currentThread().getName() + ":" + i);
  21.         }
  22.     }
  23. }

image.pngimage.png这就是线程礼让，让一点，程度轻微。

  1. package mythread;
  3. /**
  4.  * 线程合并：这里，t.join()是指t线程加入进来之后，
  5.  * main线程等待t线程结束后再执行，让整个线程，程度较深。
  6.  */
  7. public class ThreadTest03 {
  8.     public static void main(String[] args) {
  9.         System.out.println("main begin...");
  10.         Thread t = new Thread(new MyRunnable2());
  11.         t.start();
  12.         try {
  13.             t.join();
  14.         } catch (InterruptedException e) {
  15.             e.printStackTrace();
  16.         }
  17.         System.out.println("main over...");
  18.     }
  19. }
  20. class MyRunnable2 implements Runnable{
  21.     @Override
  22.     public void run() {
  23.         for (int i = 0; i < 5; i++) {
  24.             System.out.println(Thread.currentThread().getName() + ":" + (i + 1));
  25.         }
  26.     }
  27. }
  29. //内容输出为：
  30. //main begin...
  31. //Thread-0:1
  32. //Thread-0:2
  33. //Thread-0:3
  34. //Thread-0:4
  35. //Thread-0:5
  36. //main over...

线程安全

假定有以下情况，两个人都去ATM上输入相同账号和密码交易，同时进行取款的动作，并且取完。由于网络存在延迟，总有一个人先取完钱，如果银行存储的数据未能及时变更，那么第二个人应该也能继续取钱，这就意味着，由于数据不同步导致的数据安全会给日常生活带来极大的麻烦。所以，数据安全是数据交易的生命，如果谈不上安全，那么就没必要进行数据交易了。由此可知，什么情况下数据不安全？①多线程并发 ②有共享的数据 ③数据有修改行为 解决办法是让线程排队执行，宁可牺牲效率，也要保证数据同步。
这里，存在同步和异步的概念，同步就是排队、相互等待，异步就是并发，谁也不用等谁。
具体解决线程并发的问题：synchronized，参数很关键：此参数为多线程共享对象 。每个Java对象都有1把锁，这个锁就是标记。注意：这个共享对象一定要选好，一定是你需要排队执行的这些线程所共享的对象。如何体现在线程周期上? 运行状态—->锁池
多线程 - 图7

一个账户类的并发安全事件★★

  1. package mythread;
  3. public class Account {
  4.     private String no;
  5.     private double balance;
  6.     Object obj = new Object();
  8.     public String getNo() {
  9.         return no;
  10.     }
  12.     public void setNo(String no) {
  13.         this.no = no;
  14.     }
  16.     public double getBalance() {
  17.         return balance;
  18.     }
  20.     public void setBalance(double balance) {
  21.         this.balance = balance;
  22.     }
  24.     public Account(String no, double balance) {
  25.         this.no = no;
  26.         this.balance = balance;
  27.     }
  29.     public Account() {
  30.     }
  32.     //取款方法
  33.     public void withdraw(double money){
  34.         //synchronized()中的小括号的数据必须是共享的，才能达到多线程排队的效果
  35.         //()写什么？哪些对象需要排队，那么小括号就写哪些对象的共享数据。
  36. //        synchronized (this){//不一定是this，只要是共享的就行，但this最佳
  37.         Object obj2 = new Object();
  38. //        synchronized (obj){//可以，因为是实例变量，共享
  39. //        synchronized (obj2){//不可以，因为是局部变量起不到排队即同步的效果
  40.         synchronized ("1"){//可以，因为常量池只有一份，共享
  41.             //取款之前：
  42.             double before = this.getBalance();
  43.             //取款之后：
  44.             double after = balance-money;
  45.             try {
  46.                 //模拟网络延迟，此时一定会出问题
  47.                 Thread.sleep(1000);
  48.             } catch (InterruptedException e) {
  49.                 e.printStackTrace();
  50.             }
  51.             //更新余额
  52.             this.setBalance(after);
  53.         }
  55.     }
  56. }
  1. package mythread;
  3. /**
  4.  * 模拟2个线程对同一个账户做取款操作
  5.  */
  6. public class AccountThread extends Thread{
  7.     //保证2个线程共享同一个账户对象
  8.     private Account act;
  10.     public AccountThread(Account act) {
  11.         this.act = act;
  12.     }
  14.     @Override
  15.     public void run() {
  16.         //run方法的执行表示取款操作，这里假设取款5000
  17.         double money = 5000;
  18.         //多线程并发执行
  19.         act.withdraw(money);
  20.         System.out.println(act.getNo() +"取款成功，余额为："+ act.getBalance());
  21.     }
  22. }
  1. package mythread;
  3. public class AccountThreadTest {
  4.     public static void main(String[] args) {
  5.         Account act = new Account("act-001", 10000.0);
  6.         Thread at1 = new AccountThread(act);
  7.         Thread at2 = new AccountThread(act);
  9.         at1.start();
  10.         at2.start();
  11.     }
  12. }

image.png

安全事件的解决方式

如何解决以上的问题呢？用同步代码块synchronized去修饰容易出现并发的那些代码块
修改withdraw()方法的代码：

  1. //取款方法
  2.     public void withdraw(double money){
  3.         //synchronized()中的小括号的数据必须是共享的，才能达到多线程排队的效果
  4.         //()写什么？哪些对象需要排队，那么小括号就写哪些对象的共享数据。
  5.         synchronized (this){//不一定是this，只要是共享的就行
  6.             //取款之前：
  7.             double before = this.getBalance();
  8.             //取款之后：
  9.             double after = balance-money;
  10.             //模拟网络延迟，此时一定会出问题
  11.             try {
  12.                 Thread.sleep(1000);
  13.             } catch (InterruptedException e) {
  14.                 e.printStackTrace();
  15.             }
  16.             //更新余额
  17.             this.setBalance(after);
  18.         }
  20.     }
  21. //输出：
  22. //act-001取款成功，余额为：5000.0
  23. //act-001取款成功，余额为：0.0

多线程 - 图9
however，synchronized也可出现在实例方法上：

  1. //取款方法
  2.     /*
  3.     synchronized出现在实例方法上，一定是锁的this，所以这种方式不灵活
  4.     缺点之二是锁的范围是整个代码块，导致整个程序的执行效率降低，这种方式不常用
  5.      */
  6.     public synchronized void withdraw(double money){
  7.             //取款之前：
  8.             double before = this.getBalance();
  9.             //取款之后：
  10.             double after = balance-money;
  11.             //模拟网络延迟，此时一定会出问题
  12.             try {
  13.                 Thread.sleep(1000);
  14.             } catch (InterruptedException e) {
  15.                 e.printStackTrace();
  16.             }
  17.             //更新余额
  18.             this.setBalance(after);
  19.         }

哪些变量有线程安全的问题？

原则：越私有，线程越安全。所以，局部变量线程安全，实例变量在堆中，静态变量在方法区中，堆和方法区都是共享的，所以实例变量和静态变量是不安全的。使用局部变量的话，建议使用StringBuilder，因为StringBuffer效率比较低。问题：为啥是变量？锁的不应该是方法或者代码块吗？
Synchronized的三种用法：
synchronized的三种写法： ①同步代码块 ②实例方法上用synchronized，一个对象一把对象锁 ③静态方法上用synchronized，就算对象创建100个，类锁永远只有1把

面试题

—四种变形：

  1. package thread.exam;
  3. /**
  4.  * 面试题：doOther的执行是否需要doSome方法的结束？
  5.  */
  6. public class Exam1 {
  7.     public static void main(String[] args) {
  8.         MyClass mc = new MyClass();
  9.         Thread t1 = new MyThread(mc);
  10.         Thread t2 = new MyThread(mc);
  11.         t1.setName("t1");
  12.         t2.setName("t2");
  14.         t1.start();
  15.         try {
  16.             //睡眠的作用是为了保证t1先执行
  17.             Thread.sleep(1000);
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  21.         t2.start();
  22.     }
  23. }
  25. class MyThread extends Thread{
  26.     private MyClass mc;
  27.     MyThread(MyClass mc){
  28.         this.mc = mc;
  29.     }
  30.     @Override
  31.     public void run() {
  32.         if (Thread.currentThread().getName().equals("t1")){
  33.             mc.doSome();
  34.         }
  35.         if (Thread.currentThread().getName().equals("t2")){
  36.             mc.doOther();
  37.         }
  38.     }
  39. }
  41. class MyClass{
  42.     public synchronized void doSome(){
  43.         System.out.println("doSome begin..");
  44.         try {
  45.             Thread.sleep(1000*5);
  46.         } catch (InterruptedException e) {
  47.             e.printStackTrace();
  48.         }
  49.         System.out.println("doSome over..");
  50.     }
  51.     public void doOther(){
  52.         System.out.println("doOther begin...");
  53.         System.out.println("doOther over...");
  54.     }
  55. }
  56. //执行结果：
  57. //doSome begin..
  58. //doOther begin...
  59. //doOther over...
  60. //doSome over..
  1. package thread.exam2;
  3. /**
  4.  * 面试题：doOther的执行是否需要doSome方法的结束？
  5.  */
  6. public class Exam2 {
  7.     public static void main(String[] args) {
  8.         MyClass mc = new MyClass();
  9.         Thread t1 = new MyThread(mc);
  10.         Thread t2 = new MyThread(mc);
  11.         t1.setName("t1");
  12.         t2.setName("t2");
  14.         t1.start();
  15.         try {
  16.             //睡眠的作用是为了保证t1先执行
  17.             Thread.sleep(1000);
  18.         } catch (InterruptedException e) {
  19.             e.printStackTrace();
  20.         }
  21.         t2.start();
  22.     }
  23. }
  25. class MyThread extends Thread{
  26.     private MyClass mc;
  27.     MyThread(MyClass mc){
  28.         this.mc = mc;
  29.     }
  30.     @Override
  31.     public void run() {
  32.         if (Thread.currentThread().getName().equals("t1")){
  33.             mc.doSome();
  34.         }
  35.         if (Thread.currentThread().getName().equals("t2")){
  36.             mc.doOther();
  37.         }
  38.     }
  39. }
  41. class MyClass{
  42.     public synchronized void doSome(){
  43.         System.out.println("doSome begin..");
  44.         try {
  45.             Thread.sleep(1000*5);
  46.         } catch (InterruptedException e) {
  47.             e.printStackTrace();
  48.         }
  49.         System.out.println("doSome over..");
  50.     }
  51.     public synchronized void doOther(){
  52.         System.out.println("doOther begin...");
  53.         System.out.println("doOther over...");
  54.     }
  55. }
  56. //执行结果：
  57. //doSome begin..
  58. //doSome over..
  59. //doOther begin...
  60. //doOther over...
  1. package thread.exam3;
  3. /**
  4.  * 面试题：doOther的执行是否需要doSome方法的结束？
  5.  */
  6. public class Exam3 {
  7.     public static void main(String[] args) {
  8.         MyClass mc1 = new MyClass();
  9.         MyClass mc2 = new MyClass();
  10.         Thread t1 = new MyThread(mc1);
  11.         Thread t2 = new MyThread(mc2);
  12.         t1.setName("t1");
  13.         t2.setName("t2");
  15.         t1.start();
  16.         try {
  17.             //睡眠的作用是为了保证t1先执行
  18.             Thread.sleep(1000);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         t2.start();
  23.     }
  24. }
  26. class MyThread extends Thread{
  27.     private MyClass mc;
  28.     MyThread(MyClass mc){
  29.         this.mc = mc;
  30.     }
  31.     @Override
  32.     public void run() {
  33.         if (Thread.currentThread().getName().equals("t1")){
  34.             mc.doSome();
  35.         }
  36.         if (Thread.currentThread().getName().equals("t2")){
  37.             mc.doOther();
  38.         }
  39.     }
  40. }
  42. class MyClass{
  43.     public synchronized void doSome(){
  44.         System.out.println("doSome begin..");
  45.         try {
  46.             Thread.sleep(1000*5);
  47.         } catch (InterruptedException e) {
  48.             e.printStackTrace();
  49.         }
  50.         System.out.println("doSome over..");
  51.     }
  52.     public synchronized void doOther(){
  53.         System.out.println("doOther begin...");
  54.         System.out.println("doOther over...");
  55.     }
  56. }
  57. //执行结果：
  58. //doSome begin..
  59. //doOther begin...
  60. //doOther over...
  61. //doSome over..
  62. //对象锁有2把锁，各自执行各自的
  1. package thread.exam4;
  3. /**
  4.  * 面试题：doOther的执行是否需要doSome方法的结束？
  5.  */
  6. public class Exam4 {
  7.     public static void main(String[] args) {
  8.         MyClass mc1 = new MyClass();
  9.         MyClass mc2 = new MyClass();
  10.         Thread t1 = new MyThread(mc1);
  11.         Thread t2 = new MyThread(mc2);
  12.         t1.setName("t1");
  13.         t2.setName("t2");
  15.         t1.start();
  16.         try {
  17.             //睡眠的作用是为了保证t1先执行
  18.             Thread.sleep(1000);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         t2.start();
  23.     }
  24. }
  26. class MyThread extends Thread{
  27.     private MyClass mc;
  28.     MyThread(MyClass mc){
  29.         this.mc = mc;
  30.     }
  31.     @Override
  32.     public void run() {
  33.         if (Thread.currentThread().getName().equals("t1")){
  34.             mc.doSome();
  35.         }
  36.         if (Thread.currentThread().getName().equals("t2")){
  37.             mc.doOther();
  38.         }
  39.     }
  40. }
  42. class MyClass{
  43.     public synchronized static void doSome(){
  44.         System.out.println("doSome begin..");
  45.         try {
  46.             Thread.sleep(1000*5);
  47.         } catch (InterruptedException e) {
  48.             e.printStackTrace();
  49.         }
  50.         System.out.println("doSome over..");
  51.     }
  52.     public synchronized static void doOther(){
  53.         System.out.println("doOther begin...");
  54.         System.out.println("doOther over...");
  55.     }
  56. }
  57. //执行结果：
  58. //doSome begin..
  59. //doSome over..
  60. //doOther begin...
  61. //doOther over...
  62. //类锁只有1把，需要等待

手写一个死锁★★

  1. package thread.deadlock;
  3. /**
  4.  * 死锁代码要求会写
  5.  * 一般面试官会要求手写，只有会写的，才会在开发中注意这事，因为死锁很难调试
  6.  */
  7. public class DeadLock {
  8.     public static void main(String[] args) {
  9.         Object o1 = new Object();
  10.         Object o2 = new Object();
  12.         //t1和t2两个线程共享o1，o2
  13.         Thread t1 = new MyThread1(o1, o2);
  14.         Thread t2 = new MyThread2(o1,o2);
  16.         t1.start();
  17.         t2.start();
  18.     }
  19. }
  20. class MyThread1 extends Thread{
  21.     Object o1;
  22.     Object o2;
  24.     public MyThread1(Object o1, Object o2) {
  25.         this.o1 = o1;
  26.         this.o2 = o2;
  27.     }
  28.     @Override
  29.     public void run() {
  30.         synchronized (o1){
  31.             try {
  32.                 //确保程序一定死锁
  33.                 Thread.sleep(1000);
  34.             } catch (InterruptedException e) {
  35.                 e.printStackTrace();
  36.             }
  37.             synchronized (o2){}
  38.         }
  39.     }
  40. }
  42. class MyThread2 extends Thread{
  43.     Object o1;
  44.     Object o2;
  46.     public MyThread2(Object o1, Object o2) {
  47.         this.o1 = o1;
  48.         this.o2 = o2;
  49.     }
  50.     @Override
  51.     public void run() {
  52.         synchronized (o2){
  53.             try {
  54.                 Thread.sleep(1000);
  55.             } catch (InterruptedException e) {
  56.                 e.printStackTrace();
  57.             }
  58.             synchronized (o1){}
  59.         }
  60.     }
  61. }

日常开发如何解决线程安全的问题？

尽量不要首选synchronized，因为synchronized会让程序的执行效率降低，用户体验不好，系统的用户吞吐量降低会导致用户体验差，在不得已的情况下再选择线程同步机制。
第一种方案，尽量使用局部变量代替“实例变量和静态变量”。
第二种方案：如果必须是实例变量，那么可以考虑创建多个对象，这样实例变量的内存就不共享了。(一个线程对应一个对象，100个线程对应100个对象，对象不共享，就没有数据安全的问题了)
第三种方案：如果不能使用局部变量，对象也不能创建多个，这个时候就只能选择synchronized了，线程同步机制。

守护线程(后台线程)

Java语言中线程分为2大类：用户线程和守护线程。守护线程又叫后台线程，一个典型的守护线程就是垃圾回收线程。一般一个守护线程是一个死循环，所有的用户线程一旦结束，守护线程就自动结束。(注：主线程main方法是一个用户线程)守护线程的用处：比如每天0：00的时候需要数据自动备份，这个需要使用到定时器，并且我们可以将定时器设置为守护线程，一直在那看着，每到0：00就备份一次，所有的用户线程如果结束了，守护线程就自动退出，没有必要再进行数据备份了。

  1. package thread;
  3. public class ThreadTest08 {
  4.     public static void main(String[] args) {
  5.         BackDateThread t = new BackDateThread();
  6.         t.setName("备份数据线程");
  7.         //启动线程之前，将线程设置为守护线程
  8.         t.setDaemon(true);
  9.         t.start();
  11.         //主线程就是用户线程
  12.         for (int i = 0; i < 10; i++) {
  13.             System.out.println(Thread.currentThread().getName() + "--->" + i);
  14.             try {
  15.                 Thread.sleep(1000);
  16.             } catch (InterruptedException e) {
  17.                 e.printStackTrace();
  18.             }
  19.         }
  20.     }
  21. }
  23. class BackDateThread extends Thread{
  24.     @Override
  25.     public void run() {
  26.         int i = 0;
  27.         //即使是死循环，但由于该线程是守护者，当用户线程结束，守护线程也会自动终止
  28.         while (true){
  29.             System.out.println(Thread.currentThread().getName() + "--->" + (++i));
  30.             try {
  31.                 Thread.sleep(1000);
  32.             } catch (InterruptedException e) {
  33.                 e.printStackTrace();
  34.             }
  35.         }
  36.     }
  37. }

定时器★★

定时器是每隔特定时间，执行特定的程序。
在Java中其实可以采用多种方式实现：可以使用sleep方法，但比较low；也可以使用java.util.Timer，可以直接用，但现在很多高级框架都是支持定时任务的，所以这种方式使用不频繁。目前实际开发中，使用较多的是Spring框架提供的SpringTask，这个框架只要进行简单的配置，就能完成定时器的任务。

  1. package thread;
  3. import java.text.ParseException;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Date;
  6. import java.util.Timer;
  7. import java.util.TimerTask;
  9. /**
  10.  * 使用定时器指定定时任务
  11.  */
  12. public class TimerTest {
  13.     public static void main(String[] args) throws ParseException {
  14.         //创建定时器对象
  15.         Timer timer = new Timer();
  16.         //创建定时器对象并指定为守护线程
  17. //        Timer timer = new Timer(true);
  19. //        timer.schedule(定时任务，第一次执行时间，间隔多久执行一次)
  20.         //注意：这里的第一次执行时间是到点才执行，不可以是过去的时间，否则从现在的时间算起
  21.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
  22.         Date firstTime = sdf.parse("2021/10/13 11:35:32 893");
  23.         //第一个参数其实可以使用匿名内部类
  24.         timer.schedule(new LogTimerTask(),firstTime,1000*3);
  25.     }
  26. }
  28. //单独编写一个定时器任务类
  29. //假设这是一个记录日志的定时任务
  30. class LogTimerTask extends TimerTask{
  32.     @Override
  33.     public void run() {
  34.         //编写你需要执行的任务就行了
  35.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss SSS");
  36.         String strTime = sdf.format(new Date());
  37.         System.out.println(strTime + ":成功完成了一次数据备份！");
  38.     }
  39. }
  41. //输出内容如下：
  42. //2021/10/13 11:35:38 007:成功完成了一次数据备份！
  43. //2021/10/13 11:35:41 006:成功完成了一次数据备份！
  44. //2021/10/13 11:35:44 006:成功完成了一次数据备份！
  45. //2021/10/13 11:35:47 007:成功完成了一次数据备份！

关于Object类的wait和notify方法

几点说明

第一，wait和notify方法不是线程对象的方法，是Java中任何一个对象都有的方法，因为这2个方法是Object类中 自带的
第二、wait方法的作用：
Object o = new Object();
o.wait();
表示让o对象上活动的线程进入等待状态，无限期等待，直到被唤醒。
第三、notify方法的作用：
Object o = new Object();
o.notify();
表示唤醒正在o对象上等待的线程。
还有一个notifyAll()方法，这个方法是唤醒o对象上处于等待的所有线程
wait方法和notify方法是建立在synchronized线程同步的基础之上的
第四、wait方法和notify方法关于是否释放锁的区别？
o.wait()会让正在o对象上活动的当前线程进入等待状态，并且释放之前占有的o对象的锁；
o.notify()只会通知而不会释放之前占有的o对象的锁

生产者消费者案例★★

  1. package thread;
  3. import java.util.ArrayList;
  4. import java.util.List;
  6. //模拟这样一个需求：
  7. //仓库我们采用list集合，且这个集合有1个元素就表示满了，0个表示空了
  8. //必须做到这样的效果：生产一个，消费一个
  9. public class ThreadTest09 {
  10.     public static void main(String[] args) {
  11.         //创建1个仓库对象，共享的
  12.         ArrayList list = new ArrayList();
  13.         //创建2个线程对象
  14.         //生产者线程
  15.         Thread t1 = new Thread(new Producer(list));
  16.         //消费者线程
  17.         Thread t2 = new Thread(new Consumer(list));
  18.         t1.setName("t1");
  19.         t2.setName("t2");
  21.         t1.start();
  22.         t2.start();
  24.     }
  25. }
  27. class Producer implements Runnable{
  28.     private List list;
  30.     public Producer(List list) {
  31.         this.list = list;
  32.     }
  33.     @Override
  34.     public void run() {
  35.         //一直生产（用死循环来模拟一直生产）
  36.         while (true){
  37.             synchronized (list){
  38.                 if (list.size()>0){
  39.                     //当前线程进入等待状态,且释放Producer之前占有的list集合的锁
  40.                     try {
  41.                         list.wait();
  42.                     } catch (InterruptedException e) {
  43.                         e.printStackTrace();
  44.                     }
  45.                 }
  46.                 //程序能执行到这里说明仓库是空的，可以生产
  47.                 Object obj = new Object();
  48.                 list.add(obj);
  49.                 System.out.println(Thread.currentThread().getName() + "--->" + obj);
  50.                 //唤醒消费者去消费
  51. //                list.notify();
  52.                 list.notifyAll();
  53.             }
  54.         }
  55.     }
  56. }
  58. class Consumer implements Runnable{
  59.     private List list;
  61.     public Consumer(List list) {
  62.         this.list = list;
  63.     }
  64.     @Override
  65.     public void run() {
  66.         //一直消费
  67.         while (true){
  68.             synchronized (list){
  69.                 if (list.size()==0){
  70.                     //仓库已经空了
  71.                     try {
  72.                         //消费者线程等待，释放掉list集合的锁
  73.                         list.wait();
  74.                     } catch (InterruptedException e) {
  75.                         e.printStackTrace();
  76.                     }
  77.                 }
  78.                 //程序能进行到此处，说明仓库中有数据进行消费
  79.                 Object obj = list.remove(0);
  80.                 System.out.println(Thread.currentThread().getName() + "-->" + obj);
  81.                 //唤醒生产者继续生产
  82. //                list.notify();
  83.                 list.notifyAll();
  84.             }
  85.         }
  86.     }
  87. }
  89. //内容输出：生产一个，消费一个
  90. //t1--->java.lang.Object@4b527522
  91. //t2-->java.lang.Object@4b527522
  92. //t1--->java.lang.Object@4a92f21c
  93. //t2-->java.lang.Object@4a92f21c
  94. //t1--->java.lang.Object@76238b4f
  95. //t2-->java.lang.Object@76238b4f
  96. ....................

小练习：使用生产者和消费者模式实现交替输出

假设只有2个线程，输出以下结果：
t1—>1
t2—>2
t1—>3
t2—>4
t1—>5
t2—>6
要求：必须交替，并且t1线程输出奇数，t2线程输出偶数。
（提示：2个线程共享一个数字，每个线程执行时都要对这个数字进行加一操作）