线程的同步

在Java中，通过同步机制，来解决线程的安全问题

同步代码块

  1. synchronized(同步监视器){
  2.     //需要被同步的代码
  3. }
  4. 说明：操作贡献数据的代码，就是需要被同步的代码
  5.      同步监视器：锁，一般来说任何类的对象都可以作为锁
  6.                 要求：多线程必须使用同一把锁
  7.                 在实现Runnable接口创建多线程的方式中，可以考虑使用this充当同步监视器

同步代码块解决实现接口的线程安全问题

  1. /**
  2.  * @author hsy
  3.  * @date 2022/12/19
  4.  */
  6. class Windows implements Runnable{
  7.     private int ticket = 100;
  9.     Object bj = new Object();
  10.     @Override
  11.     public void run() {
  13.         while (true){
  14.             synchronized (bj) { //也可以用synchronized(this)
  15.                 if (ticket > 0) {
  16.                     try {
  17.                         Thread.sleep(100);
  18.                     } catch (InterruptedException e) {
  19.                         throw new RuntimeException(e);
  20.                     }
  21.                     System.out.println(Thread.currentThread().getName()+":买票，票号为:" + ticket);
  22.                     ticket--;
  23.                 } else {
  24.                     break;
  25.                 }
  26.             }
  27.         }
  28.     }
  29. }
  30. public class WindowTest {
  31.     public static void main(String[] args) {
  32.         Windows w = new Windows();
  33.         Thread w2 = new Thread(w);
  34.         Thread w3 = new Thread(w);
  35.         Thread w1 = new Thread(w);
  36.         w1.setName("窗口1");
  37.         w2.setName("窗口2");
  38.         w3.setName("窗口3");
  39.         w1.start();
  40.         w2.start();
  41.         w3.start();
  42.     }
  43. }

同步代码块解决继承的线程安全问题

  1. /**
  2.  * 创建多线程：方式二：实现Runnable接口
  3.  * @author hsy
  4.  * @date 2022/12/19
  5.  */
  7. class Window2 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.             synchronized (obj){
  15.                 if(ticket>0){
  16.                     try {
  17.                         Thread.sleep(100);
  18.                     } catch (InterruptedException e) {
  19.                         throw new RuntimeException(e);
  20.                     }
  21.                     System.out.println(getName()+":买票，票号:"+ticket);
  22.                     ticket--;
  23.                 }else {
  24.                     break;
  25.                 }
  26.             }
  27.         }
  28.     }
  29. }
  30. public class WindowTest2 {
  31.     public static void main(String[] args) {
  32.         Window2 t1 = new Window2();
  33.         Window2 t2 = new Window2();
  34.         Window2 t3 = new Window2();
  36.         t1.setName("窗口1");
  37.         t2.setName("窗口2");
  38.         t3.setName("窗口3");
  40.         t1.start();
  41.         t2.start();
  42.         t3.start();
  43.     }
  44. }

同步方法

  1. //在方法声明中加上synchronized
  2.  private synchronized void show(){
  3.      //方法体
  4.  }

同步方法解决实现接口的线程安全问题

  1. /**
  2.  * @author hsy
  3.  * @date 2022/12/19
  4.  */
  6. class Windows3 implements Runnable{
  7.     private int ticket = 100;
  9.     @Override
  10.     public void run() {
  12.         while (true){
  13.             show();
  14.         }
  15.     }
  16.     private synchronized void show(){
  17.         if (ticket > 0) {
  18.             try {
  19.                 Thread.sleep(100);
  20.             } catch (InterruptedException e) {
  21.                 throw new RuntimeException(e);
  22.             }
  23.             System.out.println(Thread.currentThread().getName()+":买票，票号为:" + ticket);
  24.             ticket--;
  25.         }
  26.     }
  27. }
  28. public class WindowTest3 {
  29.     public static void main(String[] args) {
  30.         Windows3 w = new Windows3();
  31.         Thread w2 = new Thread(w);
  32.         Thread w3 = new Thread(w);
  33.         Thread w1 = new Thread(w);
  34.         w1.setName("窗口1");
  35.         w2.setName("窗口2");
  36.         w3.setName("窗口3");
  37.         w1.start();
  38.         w2.start();
  39.         w3.start();
  40.     }
  41. }

同步方法解决继承的线程安全问题

  1. /**
  2.  * @author hsy
  3.  * @date 2022/12/19
  4.  */
  5. class Window4 extends Thread{
  6.     private static int ticket = 100;
  8.     @Override
  9.     public void run() {
  10.         while (true){
  11.             show();
  12.         }
  13.     }
  14.     private static synchronized void show(){
  15.         if(ticket>0){
  16.             try {
  17.                 Thread.sleep(100);
  18.             } catch (InterruptedException e) {
  19.                 throw new RuntimeException(e);
  20.             }
  21.             System.out.println(Thread.currentThread().getName()+":买票，票号:"+ticket);
  22.             ticket--;
  23.         }
  24.     }
  25. }
  26. public class WindowTest4 {
  27.     public static void main(String[] args) {
  28.         Window4 t1 = new Window4();
  29.         Window4 t2 = new Window4();
  30.         Window4 t3 = new Window4();
  32.         t1.setName("窗口1");
  33.         t2.setName("窗口2");
  34.         t3.setName("窗口3");
  36.         t1.start();
  37.         t2.start();
  38.         t3.start();
  39.     }
  40. }

关于同步方法：

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

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

死锁问题

死锁：

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

解决方法：

  • 专门的算法、原则
  • 尽量减少同步资源的定义
  • 尽量避免嵌套同步

实例：

  1. /**
  2.  * 演示死锁问题
  3.  * @author hsy
  4.  * @date 2022/12/20
  5.  */
  6. public class ThreadTest {
  7.     public static void main(String[] args) {
  8.         StringBuffer s1 = new StringBuffer();
  9.         StringBuffer s2 = new StringBuffer();
  11.         new Thread(){
  12.             @Override
  13.             public void run() {
  15.                 synchronized (s1){
  16.                     s1.append("a");
  17.                     s2.append("1");
  19.                     try {
  20.                         Thread.sleep(100);
  21.                     } catch (InterruptedException e) {
  22.                         throw new RuntimeException(e);
  23.                     }
  24.                     synchronized (s2){
  25.                         s1.append("b");
  26.                         s2.append("2");
  28.                         System.out.println(s1);
  29.                         System.out.println(s2);
  30.                     }
  31.                 }
  32.             }
  33.         }.start();
  35.         new Thread(new Runnable() {
  36.             @Override
  37.             public void run() {
  38.                 synchronized (s2){
  39.                     s1.append("c");
  40.                     s2.append("3");
  42.                     try {
  43.                         Thread.sleep(100);
  44.                     } catch (InterruptedException e) {
  45.                         throw new RuntimeException(e);
  46.                     }
  47.                     synchronized (s1){
  48.                         s1.append("d");
  49.                         s2.append("4");
  51.                         System.out.println(s1);
  52.                         System.out.println(s2);
  53.                     }
  54.                 }
  55.             }
  56.         }).start();
  57.     }
  58. }

Lock(锁)

  • 从JDK5.0开始，Java提供了更强大的线程同步机制———-通过显示定义同步锁对象来实现对象，同步锁使用Lock对象充当
    • java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象
    • ReentrantLock实现了Lock，它拥有与synchronized相同的并发性和内存语句，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁

synchronized与Lock的一同

相同：二者都可以解决线程安全问题

不同：synchronized机制在执行完相应的同步代码之后，自动释放代码监视器

  1.         Lock需要手动启动同步和关闭同步

image.png