ToB企服应用市场:ToB评测及商务社交产业平台

标题: Java多线程（二） [打印本页]

---

作者: 东湖之滨    时间: 2022-9-16 17:14
标题: Java多线程（二）
Java多线程（二）


目录

• Java多线程（二）
  
  
  
  • 
    
    
    
    • 四、线程的同步
      
      
      
      • 4.1 线程同步的引入：
        
      • 4.2 线程同步的方式之一：同步代码块
        
      • 4.3 线程同步的方式之二：同步方法
        
      • 4.4 同步的优势与局限：
        
      • 4.5 线程安全的单例模式之懒汉式
        
      • 4.6 同步锁机制：
        
      • 4.7 释放锁的操作：
        
      • 4.8 不会释放锁的操作：
        
      • 4.9 线程的死锁问题
        
      • 4.10 线程同步的方式之三：Lock锁
        
      • 4.11 （简单介绍）公平锁和非公平锁
        
      
      
    
    
  
  

四、线程的同步

4.1 线程同步的引入：

• 多线程出现了安全问题。
  
• 问题的原因： 当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。例如：买票问题、银行卡消费问题等等。
  
• 解决办法： 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
  

​                所以，Java 对于多线程的安全问题提供了专业的解决方式：同步机制。
4.2 线程同步的方式之一：同步代码块

• 语法格式：
  

1. synchronized (对象/同步监视器){        //得到对象的锁，才能操作同步代码
2.         // 需要被同步的代码
3. }

复制代码

说明：
​        （1）操作共享数据的代码，即为需要被同步的代码。  --> 不能包含代码多了，也不能包含代码少了。
​        （2）共享数据：多个线程共同操作的变量。
​        （3）同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
​        （4）要求：多个线程必须要共用同一把锁。

• 使用同步代码块解决在实现 Runnable 接口的方式创建多线程的线程安全问题
  

1. //        例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式
2. class Window1 implements Runnable{
4.     private int ticket = 100;
5. //    Object obj = new Object();
6.     @Override
7.     public void run() {
8. //      Object obj = new Object();
9.         while(true){
10.             // 同步代码块---begin
11.             synchronized (this){        // 此时的this：唯一的 Window1 的对象w   //方式二：synchronized (object) {
13.                 if (ticket > 0) {
15.                     try {
16.                         Thread.sleep(100);
17.                     } catch (InterruptedException e) {
18.                         e.printStackTrace();
19.                     }
21.                     System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
22.                     ticket--;
23.                 } else {
24.                     break;
25.                 }
26.             }
27.             // 同步代码块---end
28.         }
29.     }
30. }
32. public class WindowTest1 {
33.     public static void main(String[] args) {
34.         Window1 w = new Window1();
36.         Thread t1 = new Thread(w);
37.         Thread t2 = new Thread(w);
38.         Thread t3 = new Thread(w);
40.         t1.setName("窗口1");
41.         t2.setName("窗口2");
42.         t3.setName("窗口3");
44.         t1.start();
45.         t2.start();
46.         t3.start();
47.     }
48. }

复制代码

• 使用同步代码块解决继承 Thread 类的方式创建多线程的线程安全问题
  

1. class Window2 extends Thread{
3.     private static int ticket = 100;
4. //    private static Object obj = new Object();
6.     @Override
7.     public void run() {
9.         while(true){
11.             synchronized (Window2.class){//        Window2.class表示window2这一个类，只会加载一次
12. //       方式二：synchronized (obj){                      
13. //              synchronized (this){        错误的方式：this分别代表着t1,t2,t3三个对象
15.                 if(ticket > 0){
17.                     try {
18.                         Thread.sleep(100);
19.                     } catch (InterruptedException e) {
20.                         e.printStackTrace();
21.                     }
23.                     System.out.println(getName() + "：卖票，票号为：" + ticket);
24.                     ticket--;
25.                 }else{
26.                     break;
27.                 }
28.             }
29.         }
30.     }
31. }
33. public class WindowTest2 {
34.     public static void main(String[] args) {
35.         Window2 t1 = new Window2();
36.         Window2 t2 = new Window2();
37.         Window2 t3 = new Window2();
39.         t1.setName("窗口1");
40.         t2.setName("窗口2");
41.         t3.setName("窗口3");
43.         t1.start();
44.         t2.start();
45.         t3.start();
46.     }
47. }

复制代码

4.3 线程同步的方式之二：同步方法

• 同步方法：即将操作共享数据的代码完整的声明在一个方法中，将该方法声明为同步方法。
  
• 语法格式：
  

1. //        将synchronized放在方法声明中，一般放在权限符和返回类型之间，表示整个方法为同步方法
2. public synchronized void 方法名 (String name){
3.         // 需要被同步的代码
4. }

复制代码

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

• 使用同步方法解决在实现 Runnable 接口的方式创建多线程的线程安全问题
  

1. class Window3 implements Runnable {
3.     private int ticket = 100;
5.     @Override
6.     public void run() {
7.         while (true) {
8.             show();
9.         }
10.     }
12.     private synchronized void show(){        //同步监视器：this
14.         if (ticket > 0) {
15.             
16.             try {
17.                 Thread.sleep(100);
18.             } catch (InterruptedException e) {
19.                 e.printStackTrace();
20.             }
22.             System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
23.             ticket--;
24.             }
25.     }
26. }
28. public class WindowTest3 {
29.     public static void main(String[] args) {
30.         Window3 w = new Window3();
32.         Thread t1 = new Thread(w);
33.         Thread t2 = new Thread(w);
34.         Thread t3 = new Thread(w);
36.         t1.setName("窗口1");
37.         t2.setName("窗口2");
38.         t3.setName("窗口3");
40.         t1.start();
41.         t2.start();
42.         t3.start();
43.     }
44. }

复制代码

• 使用同步方法解决继承 Thread 类的方式创建多线程的线程安全问题
  

1. class Window4 extends Thread {
3.     private static int ticket = 100;
5.     @Override
6.     public void run() {
8.         while (true) {
9.             show();
10.         }
11.     }
12.    
13.     private static synchronized void show(){        //同步监视器：Window4.class
14.         //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
15.         if (ticket > 0) {
17.             try {
18.                 Thread.sleep(100);
19.             } catch (InterruptedException e) {
20.                 e.printStackTrace();
21.             }
23.             System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
24.             ticket--;
25.         }
26.     }
27. }
30. public class WindowTest4 {
31.     public static void main(String[] args) {
32.         Window4 t1 = new Window4();
33.         Window4 t2 = new Window4();
34.         Window4 t3 = new Window4();
36.         t1.setName("窗口1");
37.         t2.setName("窗口2");
38.         t3.setName("窗口3");
40.         t1.start();
41.         t2.start();
42.         t3.start();
44.     }
45. }

复制代码

总结：
通过上面四个售票例子可以看出：
在实现 Runnable 接口创建多线程的方式中，我们可以考虑使用 this 充当同步监视器。
而在继承Thread类创建多线程的方式一般不使用 this 充当同步监视器，因为每个线程的 this 为该线程的实例对象，不满足多个线程共用一把锁，所以一般考虑用当前类本身充当。

4.4 同步的优势与局限：

• 优势：解决了线程的安全问题。
  
• 局限： 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。也可能会造成死锁问题。
  

4.5 线程安全的单例模式之懒汉式

1. public class BankTest {
3. }
5. class Bank{
7.     private Bank(){}
9.     private static Bank instance = null;
11.     public static Bank getInstance(){
12.         //方式一：效率稍差
13. //        synchronized (Bank.class) {
14. //            if(instance == null){
15. //                instance = new Bank();
16. //            }
17. //            return instance;
18. //        }
19.         //方式二：效率更高
20.         if(instance == null){
21.             synchronized (Bank.class) {
22.                 if(instance == null){
23.                     instance = new Bank();
24.                 }
25.             }
26.         }
27.         return instance;
28.     }
29. }
31. /*
32.         方式二效率更高的原因：
33.         不需要每个线程都要进去同步方法里面去，可能只有最前面几个进程进入同步方法。
34.         而方式一是所有线程都要进入同步方法导致效率较低。
35. */

复制代码

4.6 同步锁机制：

• 同步机制中的锁在《Thinking in Java》中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。
  
• synchronized的锁是什么？
  
  
  
  • 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。
    
  • 同步方法的锁：静态方法（类名.class）、非静态方法（this）。
    
  • 同步代码块：可以自己指定，很多时候也是指定为this或类名.class。
    
  
  
• 注意：
  
  
  
  • 必须确保使用同一个资源的多个线程共用一把锁，否则就无法保证共享资源的安全 。
    
  • 一个线程类中的所有静态方法共用同一把锁（类名.class），所有非静态方法共用同一把锁（this），同步代码块（指定需谨慎）。
    
  
  

4.7 释放锁的操作：

• 当前线程的同步方法、同步代码块执行结束。
  
• 当前线程在同步代码块、同步方法中遇到 break、return 终止了该代码块、该方法的继续执行。
  
• 当前线程在同步代码块、同步方法中出现了未处理的 Error 或 Exception，导致异常结束。
  
• 当前线程在同步代码块、同步方法中执行了线程对象的 wait() 方法，当前线程暂停，并释放锁。
  

4.8 不会释放锁的操作：

• 线程执行同步代码块或同步方法时，程序调用 Thread.sleep()、 Thread.yield() 方法暂停当前线程的执行。
  
• 线程执行同步代码块时，其他线程调用了该线程的 suspend() 方法将该线程挂起，该线程不会释放锁（同步监视器）。
  应尽量避免使用suspend()和resume()来控制线程
  

4.9 线程的死锁问题

• 死锁：
  
  
  
  • 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
    
  • 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
    
  
  
• 解决方法：
  
  
  
  • 专门的算法、原则。
    
  • 尽量减少同步资源的定义。
    
  • 尽量避免嵌套同步。
    
  
  
• 例子：
  

1. //死锁的演示
2. class A {
3.         public synchronized void foo(B b) { //同步监视器：A类的对象：a
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() {//同步监视器：A类的对象：a
17.                 System.out.println("进入了A类的last方法内部");
18.         }
19. }
21. class B {
22.         public synchronized void bar(A a) {//同步监视器：b
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() {//同步监视器：b
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();
62.                 dl.init();
63.         }
64. }

复制代码

• 注意：
  不是程序运行成功就说明程序里面没有死锁问题，很多时候出现死锁是一个概率问题。在开发中应尽量避免死锁情况。
  

4.10 线程同步的方式之三：Lock锁

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

1. class A{
2.     //1.实例化ReentrantLock
3.         private final ReentrantLock lock = new ReenTrantLock();
4.    
5.         public void m(){
6.         //2.调用锁定方法lock()
7.                 lock.lock();
8.                 try{
9.                         //保证线程安全的代码;
10.                 }
11.                 finally{
12.             //3.调用解锁方法：unlock()
13.                         lock.unlock();
14.                 }
15.         }
16. }

复制代码

• （面试题）synchronized 与 Lock 的对比
  
  
  
  • 相同：二者都可以解决线程安全问题。
    
  • 不同：
    
    
    • Lock 是显式锁（手动开启和关闭锁），synchronized 是隐式锁，出了作用域自动释放。
      
    • Lock 只有代码块锁，synchronized 有代码块锁和方法锁。
      
    • 使用 Lock 锁，JVM 将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）。
      
    
    
  
  
• 优先使用顺序：
  

Lock —— 同步代码块（已经进入了方法体，分配了相应资源） ——  同步方法（在方法体之外）
4.11 （简单介绍）公平锁和非公平锁

• 公平锁（Fair）：加锁前检查是否有排队等待的线程，优先排队等待的线程，先来先得。
  非公平锁（Nonfair）：加锁时不考虑排队等待问题，直接尝试获取锁，获取不到自动到队尾等待。
  
• Java中的 ReentrantLock 默认的 lock() 方法采用的是非公平锁。
  

1. //        源码：
2. //        ReentrantLock当中的lock（）方法，是通过static内部类sync来进行锁操作
3. public void lock()
4. {
5.      sync.lock();
6. }
7. -------------------------------------------------------------------
8. //定义成final型的成员变量，在构造方法中进行初始化
9. private final Sync sync;
10. //无参数默认非公平锁
11. public ReentrantLock()
12. {
13.     sync = new NonfairSync();
14. }
15. //根据参数初始化为公平锁或者非公平锁
16. public ReentrantLock(boolean fair)
17. {
18.     sync = fair ? new FairSync() : new NonfairSync();
19. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4