1、通过同步机制，来解决线程的安全问题

1.1、方式一：同步代码块

synchronized(同步监视器){
//需要同步的代码
}
说明：

  • 操作共享数据的代码，即为需要被同步的代码 ——>不能包含代码多了，也不能包含代码少了
  • 共享数据：多线程共同操作的变量。比如 ticket就是共享数据
  • 同步监视器：俗称 锁，任何一个类的对象，都可以来充当锁
    • 要求：多个线程必须要共用同一把锁

补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

  1. package com.haiyang.java;
  3. /**
  4.  * @author 杨磊
  5.  * @create 2021-09-24 22:35
  6.  */
  7. class Window1 implements Runnable{
  8.     private int ticket = 100;
  9.     private Object obj = new Object();
  10.     @Override
  11.     public void run() {
  13.         while (true) {
  14.             synchronized (this){
  15.             if (ticket > 0) {
  16.                 try {
  17.                     Thread.sleep(100);
  18.                 } catch (InterruptedException e) {
  19.                     e.printStackTrace();
  20.                 }
  21.                 System.out.println(Thread.currentThread().getName() + "卖票，票号为:" + ticket);
  22.                 ticket--;
  23.             } else {
  24.                 System.out.println("票已经卖完了");
  25.                 break;
  26.             }
  27.         }
  28.         }
  29.     }
  30. }
  32. public class WindowTest1 {
  33.     public static void main(String[] args) {
  34.         Window1 w1 = new Window1();
  35.         Thread t1 = new Thread(w1);
  36.         Thread t2 = new Thread(w1);
  37.         Thread t3 = new Thread(w1);
  39.         t1.setName("窗口一");
  40.         t2.setName("窗口二");
  41.         t3.setName("窗口三");
  43.         t1.start();
  44.         t2.start();
  45.         t3.start();
  46.     }
  47. }
  1. /**
  2.  * 使用同步代码块解决继承Thread类的方式的线程安全问题
  3.  *
  4.  * 例子：创建三个c窗口卖票，总票数为100张
  5.  */
  6. class Windows extends Thread{
  8.     private static int ticket = 100;
  9.     private static Object obj = new Object();
  11.     @Override
  12.     public void run() {
  13.         while(true){
  14.             //正确的
  15. //            synchronized (obj) {
  16.             synchronized (Windows.class){   //Class clazz = Windows.class
  17.             //错误的，因为此时this表示的是t1,t2,t3三个对象
  18. //            synchronized (this) {
  19.                 if (ticket > 0) {
  21.                     try {
  22.                         Thread.sleep(100);
  23.                     } catch (InterruptedException e) {
  24.                         e.printStackTrace();
  25.                     }
  27.                     System.out.println(getName() + ":卖票，票号为: " + ticket);
  28.                     ticket--;
  29.                 } else {
  30.                     break;
  31.                 }
  32.             }
  33.         }
  34.     }
  35. }
  37. public class WindowsTest2 {
  38.     public static void main(String[] args) {
  39.         Windows t1 = new Windows();
  40.         Windows t2 = new Windows();
  41.         Windows t3 = new Windows();
  43.         t1.setName("窗口1");
  44.         t2.setName("窗口2");
  45.         t3.setName("窗口3");
  47.         t1.start();
  48.         t2.start();
  49.         t3.start();
  50.     }
  51. }

1.2、方式二：同步方法

如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的

关于同步方法的总结

  • 同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
  • 非静态的同步方法，同步监视器是 ：this
  • 静态的同步方法，同步监视器是 ： 当前类本身

同步的方式，解决了线程的安全问题。—-好处
操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。—-局限性

  1. package com.haiyang.java;
  3. /**
  4.  * 使用同步方法解决实现Runnable接口的线程安全问题
  5.  * @author 杨磊
  6.  * @create 2021-09-25 12:47
  7.  */
  8. public class WindowTest3 {
  9.     public static void main(String[] args) {
  10.         Window2 w2 = new Window2();
  11.         Thread t1 = new Thread(w2);
  12.         Thread t2 = new Thread(w2);
  13.         Thread t3 = new Thread(w2);
  15.         t1.setName("窗口一");
  16.         t2.setName("窗口二");
  17.         t3.setName("窗口三");
  19.         t1.start();
  20.         t2.start();
  21.         t3.start();
  22.     }
  23. }
  24. class Window2 implements Runnable{
  25.     private int ticket = 100;
  26.     boolean flag = true;
  27.     @Override
  28.     public void run() {
  29.         while (flag){
  30.                show();
  32.         }
  33.     }
  34.     private synchronized void show() { //同步监视器是 this
  35.         if (ticket > 0) {
  36.             try {
  37.                 Thread.sleep(100);
  38.             } catch (InterruptedException e) {
  39.                 e.printStackTrace();
  40.             }
  41.             System.out.println(Thread.currentThread().getName() + "买票，票号为" + ticket);
  42.             ticket--;
  43.         }else {
  44.             flag = false;
  45.         }
  47.     }
  48. }
  1. package com.haiyang.java;
  3. /**
  4.  * 使用同步方法完成对继承Thread类的线程安全问题
  5.  * @author 杨磊
  6.  * @create 2021-09-25 12:58
  7.  *
  8.  *
  9.  *关于同步方法的总结
  10.  * 1、同步方法仍然涉及到同步监视器，只是不需要我们显示的声明
  11.  * 2、非静态的同步方法，同步监视器是 ：this
  12.  *      静态的同步方法，同步监视器是 ： 当前类本身
  13.  *
  14.  */
  15. public class WindowTest4 {
  18.     public static void main(String[] args) {
  19.         Window4 w1 = new Window4();
  20.         Window4 w2 = new Window4();
  21.         Window4 w3 = new Window4();
  22.         w1.setName("窗口一");
  23.         w2.setName("窗口二");
  24.         w3.setName("窗口三");
  26.         w1.start();
  27.         w2.start();
  28.         w3.start();
  29.     }
  31. }
  32. class Window4 extends Thread{
  33.     private static int ticket = 100;
  34.     static boolean flag = true;
  35.     @Override
  36.     public void run() {
  37.         while (flag){
  38.             show();
  39.         }
  40.     }
  42.     private static synchronized void show() { //同步监视器 Window4.class
  43.         if (ticket > 0){
  44.             try {
  45.                 Thread.sleep(100);
  46.             } catch (InterruptedException e) {
  47.                 e.printStackTrace();
  48.             }
  49.             System.out.println(Thread.currentThread().getName() + "买票，票号为" + ticket);
  50.             ticket--;
  51.         }else {
  52.             flag = false;
  53.         }
  54.     }
  55. }

1.3、方式三：lock锁

  • 实例化ReentrantLock对象
  • 调用锁定方法lock()
  • 调用解锁方法：unlock()

注意：如果同步代码有异常，要将unlock()写入finally语句块

  1. import java.util.concurrent.locks.ReentrantLock;
  2. /**
  3.  * 解决线程安全的方式三： lock锁 ---JDK5新增
  4.  * @author 杨磊
  5.  * @create 2021-09-25 15:20
  6.  */
  7. public class LockTest {
  8.     public static void main(String[] args) {
  9.         Window w1 = new Window();
  10.         Thread t1 = new Thread(w1);
  11.         Thread t2 = new Thread(w1);
  12.         Thread t3 = new Thread(w1);
  13.         t1.setName("窗口一");
  14.         t2.setName("窗口二");
  15.         t3.setName("窗口三");
  17.         t1.start();
  18.         t2.start();
  19.         t3.start();
  20.     }
  21. }
  22. class Window implements Runnable{
  23.     private int ticket = 100;
  24.     //1、实例化 ReentrantLock
  25.     private ReentrantLock lock = new ReentrantLock();
  26.     @Override
  27.     public void run() {
  28.         while (true){
  29.             try {
  30.                 //2、调用锁定方法lock()
  31.                 lock.lock();
  32.                 if (ticket > 0){
  33.                     Thread.sleep(100);
  34.                     System.out.println(Thread.currentThread().getName() + "卖票，票号为:" + ticket);
  35.                     ticket--;
  36.                 }else {
  37.                     System.out.println("票已经卖完了");
  38.                     break;
  39.                 }
  40.             } catch (InterruptedException e) {
  41.                 e.printStackTrace();
  42.             } finally {
  43.                 //3、调用解锁方法 : unlock()
  44.                 lock.unlock();
  45.             }
  47.         }
  48.     }
  49. }

1.4、面试题：synchronized 与 Lock的异同？

相同：

  • 二者都可以解决线程安全问题

不同：

  • synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
  • Lock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

    1.5、优先使用顺序：

    Lock —-> 同步代码块（已经进入了方法体，分配了相应资源）——> 同步方法（在方法体之外） ```java package com.haiyang.exer;

import java.util.concurrent.locks.ReentrantLock;

/**

  • @author 杨磊

  • @create 2021-09-25 15:40 */ public class AccountTest { public static void main(String[] args) {

    1.  Account acct = new Account(0);
    2.  Customer c1 = new Customer(acct);
    3.  Customer c2 = new Customer(acct);
    4.  c1.setName("甲用户");
    5.  c2.setName("乙用户");
    7.  c1.start();
    8.  c2.start();

    } } class Account { private static ReentrantLock lock = new ReentrantLock(); private double balance;

    public Account(double balance) {

    1.  this.balance = balance;

    }

    public synchronized void deposit(double amt){

    1.  if (amt > 0){
    2.      balance += amt;
    3.      try {
    4.          Thread.sleep(1000);
    5.      } catch (InterruptedException e) {
    6.          e.printStackTrace();
    7.      }
    8.      System.out.println(Thread.currentThread().getName() + "存钱成功，余额为" + balance);
    9.  }

    } } class Customer extends Thread{ private Account acct;

    public Customer(Account acct) {

    1.  this.acct = acct;

    }

    @Override public void run() {

    1.  for (int i = 0; i < 3; i++) {
    2.      acct.deposit(1000);
    3.  }

    } }

  1. <a name="RCmLi"></a>
  2. # 2、线程安全的单例模式之懒汉式
  3. ```java
  4. /**
  5.  * 使用同步机制将单例模式中的懒汉式改写为线程安全的
  6.  */
  7. public class BankTest {
  8. }
  9. class Bank{
  10.     private Bank(){}
  11.     private static Bank instance = null;
  12.     public static Bank getInstance(){
  13.         //方式一：效率稍差
  14.         //快捷键:Alt+Shift+Z
  15. //        synchronized (Bank.class) {
  16. //            if(instance == null){
  17. //                instance = new Bank();
  18. //            }
  19. //            return instance;
  20. //        }
  22.         //方式二：效率较高
  23.         if(instance == null) {
  24.             synchronized (Bank.class) {
  25.                 if (instance == null) {
  26.                     instance = new Bank();
  27.                 }
  28.             }
  29.         }
  30.         return instance;
  31.     }
  32. }

3、死锁的问题

  • 死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
  • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

  • 我们使用同步时，要避免出现死锁。 ```java /**

    • 演示线程的死锁 *
    • 1.死锁的理解：不同的线程分别占用对方需要的同步资源不放弃，
    • 都在等待对方放弃自己需要的同步资源，就形成了线程的死锁
    • 2.说明:
    • 》出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续

    • 》我们使用同步时，要避免出现死锁。 */ public class ThreadTest { public static void main(String[] args) {

      StringBuffer s1 = new StringBuffer(); StringBuffer s2 = new StringBuffer();

      new Thread(){ @Override public void run() {

      1.    synchronized (s1){
      2.        s1.append("a");
      3.        s2.append("1");
      5.        try {
      6.            Thread.sleep(100);
      7.        } catch (InterruptedException e) {
      8.            e.printStackTrace();
      9.        }
      11.        synchronized (s2){
      12.            s1.append("b");
      13.            s2.append("2");
      15.            System.out.println(s1);
      16.            System.out.println(s2);
      17.        }
      18.    }

      } }.start();

      new Thread(new Runnable() { @Override public void run() {

      1.    synchronized (s2){
      2.        s1.append("c");
      3.        s2.append("3");
      5.        try {
      6.            Thread.sleep(100);
      7.        } catch (InterruptedException e) {
      8.            e.printStackTrace();
      9.        }
      11.        synchronized (s1){
      12.            s1.append("d");
      13.            s2.append("4");
      15.            System.out.println(s1);
      16.            System.out.println(s2);
      17.        }
      18.    }

      } }).start(); } }

  1. ```java
  2. class A {
  3.     public synchronized void foo(B b) {
  4.         System.out.println("当前线程名: " + Thread.currentThread().getName()
  5.                 + " 进入了A实例的foo方法"); // ①
  6.         try {
  7.             Thread.sleep(200);
  8.         } catch (InterruptedException ex) {
  9.             ex.printStackTrace();
  10.         }
  11.         System.out.println("当前线程名: " + Thread.currentThread().getName()
  12.                 + " 企图调用B实例的last方法"); // ③
  13.         b.last();
  14.     }
  16.     public synchronized void last() {
  17.         System.out.println("进入了A类的last方法内部");
  18.     }
  19. }
  21. class B {
  22.     public synchronized void bar(A a) {
  23.         System.out.println("当前线程名: " + Thread.currentThread().getName()
  24.                 + " 进入了B实例的bar方法"); // ②
  25.         try {
  26.             Thread.sleep(200);
  27.         } catch (InterruptedException ex) {
  28.             ex.printStackTrace();
  29.         }
  30.         System.out.println("当前线程名: " + Thread.currentThread().getName()
  31.                 + " 企图调用A实例的last方法"); // ④
  32.         a.last();
  33.     }
  35.     public synchronized void last() {
  36.         System.out.println("进入了B类的last方法内部");
  37.     }
  38. }
  40. public class DeadLock implements Runnable {
  41.     A a = new A();
  42.     B b = new B();
  44.     public void init() {
  45.         Thread.currentThread().setName("主线程");
  46.         // 调用a对象的foo方法
  47.         a.foo(b);
  48.         System.out.println("进入了主线程之后");
  49.     }
  51.     public void run() {
  52.         Thread.currentThread().setName("副线程");
  53.         // 调用b对象的bar方法
  54.         b.bar(a);
  55.         System.out.println("进入了副线程之后");
  56.     }
  58.     public static void main(String[] args) {
  59.         DeadLock dl = new DeadLock();
  60.         new Thread(dl).start();
  61.         dl.init();
  62.     }
  63. }