AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java多线程（二）、线程的生命周期、线程的同步、Synchronized的使用方法、同步代码块、同步方法、同步机制中的锁、同步的范围、Lock(锁、不会释放锁的操作、单例设计模式之懒汉式(线程安全)

2022-08-28 124
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： synchronized与Lock的对比、线程的死锁问题、JDK中用Thread.State类定义了线程的几种状态、新建，就绪，运行，阻塞，死亡、使用同步代码块、同步方法解决实现Runnable接口的线程安全问题、使用同步代码块、同步方法处理继承Thread类的方式中的线程安全问题、使用同步机制将单例模式中的懒汉式改写为线程安全的、演示线程的死锁问题、解决线程安全问题的方式三：Lock锁-JDK5.0新增、Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释

@[toc]

1.多线程

1.3线程的生命周期

1.3.1JDK中用Thread.State类定义了线程的几种状态

要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态
就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
运行：当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能
阻塞：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态
死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束

1.3.2线程的生命周期

在这里插入图片描述

1.4线程的同步

1.4.1问题的提出

多个线程执行的不确定性引起执行结果的不稳定
多个线程对账本的共享，会造成操作的不完整性，会破坏数据
在这里插入图片描述

1.4.2例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式

1.问题：卖票过程中，出现了重票、错票 -->出现了线程的安全问题
2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。
3.如何解决：当一个线程a在操作ticket的时候，其他线程不能参与进来。直到线程a操作完ticket时，其他线程才可以开始操作ticket。这种情况即使线程a出现了阻塞，也不能被改变。

package com.my.java;

/**
 * 例子：创建三个窗口卖票，总票数为100张.使用实现Runnable接口的方式
 *
 * @author Redamancy
 * @create 2022-08-06 15:41
 */

class Window1 implements Runnable{
    private int ticket = 100;



    @Override
    public void run() {


        while (true){
            if(ticket > 0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                ticket--;
            }else{
                break;
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }

}

在这里插入图片描述

  1. 多线程出现了安全问题
  2. 问题的原因：

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行。导致共享数据的错误。

  1. 解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。

1.4.3Synchronized的使用方法

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

1.4.3.1方式一：同步代码块

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

说明：

  1. 操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。
  1. 共享数据：多个线程共同操作的变量。比如：ticket就是共享数据。
  2. 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
  3. 要求：多个线程必须要共用同一把锁。
  4. 同步的方式，解决了线程的安全问题。---好处

操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性

1.4.3.1.1使用同步代码块解决实现Runnable接口的线程安全问题
package com.my.java;

/**
 * @author Redamancy
 * @create 2022-08-06 15:41
 */

class Window1 implements Runnable{
    private int ticket = 100;
//    Object obj = new Object();//第一种方式，new一个object类
//    Dog dog = new Dog();// 第二种方式创建一个Dog类，然后new一下


    @Override
    public void run() {


        while (true){
//            synchronized(obj) {//第一种方式，new一个object类  obj
//            synchronized(dog) {// 第二种方式创建一个Dog类，然后new一下  dog
            synchronized(this) { //此时的this：唯一的Window1的对象
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}
public class WindowTest1 {
    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }

}
class Dog{

}
窗口1:买票，票号为：100
窗口1:买票，票号为：99
窗口1:买票，票号为：98
窗口1:买票，票号为：97
窗口1:买票，票号为：96
窗口1:买票，票号为：95
窗口3:买票，票号为：94
窗口3:买票，票号为：93
窗口3:买票，票号为：92
窗口3:买票，票号为：91
窗口3:买票，票号为：90
窗口2:买票，票号为：89
窗口2:买票，票号为：88
窗口2:买票，票号为：87
窗口2:买票，票号为：86
窗口2:买票，票号为：85
窗口2:买票，票号为：84
窗口2:买票，票号为：83
窗口2:买票，票号为：82
窗口2:买票，票号为：81
窗口2:买票，票号为：80
窗口2:买票，票号为：79
窗口2:买票，票号为：78
窗口2:买票，票号为：77
窗口3:买票，票号为：76
窗口3:买票，票号为：75
窗口3:买票，票号为：74
窗口3:买票，票号为：73
窗口3:买票，票号为：72
窗口3:买票，票号为：71
窗口3:买票，票号为：70
窗口3:买票，票号为：69
窗口3:买票，票号为：68
窗口3:买票，票号为：67
窗口3:买票，票号为：66
窗口3:买票，票号为：65
窗口3:买票，票号为：64
窗口1:买票，票号为：63
窗口1:买票，票号为：62
窗口1:买票，票号为：61
窗口1:买票，票号为：60
窗口1:买票，票号为：59
窗口1:买票，票号为：58
窗口1:买票，票号为：57
窗口1:买票，票号为：56
窗口1:买票，票号为：55
窗口1:买票，票号为：54
窗口1:买票，票号为：53
窗口1:买票，票号为：52
窗口1:买票，票号为：51
窗口1:买票，票号为：50
窗口3:买票，票号为：49
窗口3:买票，票号为：48
窗口3:买票，票号为：47
窗口3:买票，票号为：46
窗口3:买票，票号为：45
窗口3:买票，票号为：44
窗口3:买票，票号为：43
窗口3:买票，票号为：42
窗口3:买票，票号为：41
窗口3:买票，票号为：40
窗口3:买票，票号为：39
窗口2:买票，票号为：38
窗口2:买票，票号为：37
窗口3:买票，票号为：36
窗口3:买票，票号为：35
窗口3:买票，票号为：34
窗口3:买票，票号为：33
窗口3:买票，票号为：32
窗口3:买票，票号为：31
窗口1:买票，票号为：30
窗口3:买票，票号为：29
窗口2:买票，票号为：28
窗口2:买票，票号为：27
窗口3:买票，票号为：26
窗口3:买票，票号为：25
窗口3:买票，票号为：24
窗口3:买票，票号为：23
窗口3:买票，票号为：22
窗口3:买票，票号为：21
窗口3:买票，票号为：20
窗口3:买票，票号为：19
窗口3:买票，票号为：18
窗口3:买票，票号为：17
窗口3:买票，票号为：16
窗口3:买票，票号为：15
窗口3:买票，票号为：14
窗口3:买票，票号为：13
窗口3:买票，票号为：12
窗口3:买票，票号为：11
窗口3:买票，票号为：10
窗口3:买票，票号为：9
窗口3:买票，票号为：8
窗口3:买票，票号为：7
窗口3:买票，票号为：6
窗口3:买票，票号为：5
窗口3:买票，票号为：4
窗口3:买票，票号为：3
窗口3:买票，票号为：2
窗口3:买票，票号为：1

Process finished with exit code 0

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

1.4.3.1.2使用同步代码块处理继承Thread类的方式中的线程安全问题
package com.my.java;

/**
 * @author Redamancy
 * @create 2022-08-07 10:34
 */
//1. 创建一个继承于Thread类的子类
class Window2 extends Thread {
    private static int ticket = 100;

    private static Object obj = new Object();

    //2. 重写Thread类的run()
    @Override
    public void run() {
        while (true){
            synchronized(obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest2 {
    public static void main(String[] args) {
        Window2 t1 = new Window2();
        Window2 t2 = new Window2();
        Window2 t3 = new Window2();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();


    }
}

在这里插入图片描述

说明：在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。

1.4.3.2方式二：同步方法

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

关于同步方法的总结：

  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。

    1. 非静态的同步方法，同步监视器是：this

    静态的同步方法，同步监视器是：当前类本身

1.4.3.2.1使用同步方法解决实现Runnable接口的线程安全问题
package com.my.java;

/**
 * @author Redamancy
 * @create 2022-08-07 16:18
 */
class Window3 implements Runnable{
    private int ticket = 100;

    @Override
    public void run() {


        while (true){
                show();
        }
    }
    private synchronized void show(){//同步监视器：this
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
            ticket--;
        }
    }
}

public class WindowTest3{
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }

}

窗口1:买票，票号为：100
窗口1:买票，票号为：99
窗口1:买票，票号为：98
窗口1:买票，票号为：97
窗口1:买票，票号为：96
窗口1:买票，票号为：95
窗口1:买票，票号为：94
窗口1:买票，票号为：93
窗口1:买票，票号为：92
窗口1:买票，票号为：91
窗口1:买票，票号为：90
窗口1:买票，票号为：89
窗口1:买票，票号为：88
窗口1:买票，票号为：87
窗口1:买票，票号为：86
窗口1:买票，票号为：85
窗口1:买票，票号为：84
窗口1:买票，票号为：83
窗口1:买票，票号为：82
窗口1:买票，票号为：81
窗口1:买票，票号为：80
窗口1:买票，票号为：79
窗口1:买票，票号为：78
窗口1:买票，票号为：77
窗口1:买票，票号为：76
窗口3:买票，票号为：75
窗口3:买票，票号为：74
窗口3:买票，票号为：73
窗口3:买票，票号为：72
窗口3:买票，票号为：71
窗口3:买票，票号为：70
窗口3:买票，票号为：69
窗口3:买票，票号为：68
窗口3:买票，票号为：67
窗口3:买票，票号为：66
窗口3:买票，票号为：65
窗口3:买票，票号为：64
窗口3:买票，票号为：63
窗口3:买票，票号为：62
窗口3:买票，票号为：61
窗口3:买票，票号为：60
窗口3:买票，票号为：59
窗口2:买票，票号为：58
窗口2:买票，票号为：57
窗口2:买票，票号为：56
窗口2:买票，票号为：55
窗口2:买票，票号为：54
窗口2:买票，票号为：53
窗口2:买票，票号为：52
窗口2:买票，票号为：51
窗口2:买票，票号为：50
窗口2:买票，票号为：49
窗口2:买票，票号为：48
窗口2:买票，票号为：47
窗口2:买票，票号为：46
窗口2:买票，票号为：45
窗口2:买票，票号为：44
窗口2:买票，票号为：43
窗口2:买票，票号为：42
窗口2:买票，票号为：41
窗口2:买票，票号为：40
窗口2:买票，票号为：39
窗口2:买票，票号为：38
窗口2:买票，票号为：37
窗口2:买票，票号为：36
窗口2:买票，票号为：35
窗口2:买票，票号为：34
窗口2:买票，票号为：33
窗口2:买票，票号为：32
窗口2:买票，票号为：31
窗口2:买票，票号为：30
窗口2:买票，票号为：29
窗口2:买票，票号为：28
窗口2:买票，票号为：27
窗口2:买票，票号为：26
窗口2:买票，票号为：25
窗口2:买票，票号为：24
窗口2:买票，票号为：23
窗口2:买票，票号为：22
窗口2:买票，票号为：21
窗口2:买票，票号为：20
窗口2:买票，票号为：19
窗口2:买票，票号为：18
窗口2:买票，票号为：17
窗口2:买票，票号为：16
窗口2:买票，票号为：15
窗口2:买票，票号为：14
窗口2:买票，票号为：13
窗口2:买票，票号为：12
窗口2:买票，票号为：11
窗口2:买票，票号为：10
窗口2:买票，票号为：9
窗口2:买票，票号为：8
窗口2:买票，票号为：7
窗口2:买票，票号为：6
窗口2:买票，票号为：5
窗口2:买票，票号为：4
窗口2:买票，票号为：3
窗口2:买票，票号为：2
窗口2:买票，票号为：1

Process finished with exit code 130

在这里插入图片描述

1.4.3.2.2使用同步方法处理继承Thread类的方式中的线程安全问题
package com.my.java;

/**
 * @author Redamancy
 * @create 2022-08-07 16:28
 */
class Window4 extends Thread {
    private static int ticket = 100;

    //2. 重写Thread类的run()
    @Override
    public void run() {
        while (true){
                show();
        }
    }
    private static synchronized void show(){//同步监视器：Window4.class
        //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
            ticket--;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 t1 = new Window4();
        Window4 t2 = new Window4();
        Window4 t3 = new Window4();


        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();


    }
}

窗口1:买票，票号为：100
窗口1:买票，票号为：99
窗口1:买票，票号为：98
窗口1:买票，票号为：97
窗口3:买票，票号为：96
窗口3:买票，票号为：95
窗口3:买票，票号为：94
窗口3:买票，票号为：93
窗口3:买票，票号为：92
窗口3:买票，票号为：91
窗口3:买票，票号为：90
窗口3:买票，票号为：89
窗口3:买票，票号为：88
窗口3:买票，票号为：87
窗口3:买票，票号为：86
窗口3:买票，票号为：85
窗口3:买票，票号为：84
窗口3:买票，票号为：83
窗口2:买票，票号为：82
窗口2:买票，票号为：81
窗口2:买票，票号为：80
窗口2:买票，票号为：79
窗口2:买票，票号为：78
窗口2:买票，票号为：77
窗口2:买票，票号为：76
窗口2:买票，票号为：75
窗口2:买票，票号为：74
窗口2:买票，票号为：73
窗口2:买票，票号为：72
窗口2:买票，票号为：71
窗口2:买票，票号为：70
窗口2:买票，票号为：69
窗口2:买票，票号为：68
窗口2:买票，票号为：67
窗口2:买票，票号为：66
窗口2:买票，票号为：65
窗口2:买票，票号为：64
窗口2:买票，票号为：63
窗口2:买票，票号为：62
窗口2:买票，票号为：61
窗口2:买票，票号为：60
窗口2:买票，票号为：59
窗口2:买票，票号为：58
窗口2:买票，票号为：57
窗口2:买票，票号为：56
窗口2:买票，票号为：55
窗口2:买票，票号为：54
窗口2:买票，票号为：53
窗口2:买票，票号为：52
窗口2:买票，票号为：51
窗口2:买票，票号为：50
窗口2:买票，票号为：49
窗口2:买票，票号为：48
窗口2:买票，票号为：47
窗口2:买票，票号为：46
窗口2:买票，票号为：45
窗口2:买票，票号为：44
窗口2:买票，票号为：43
窗口2:买票，票号为：42
窗口3:买票，票号为：41
窗口3:买票，票号为：40
窗口3:买票，票号为：39
窗口3:买票，票号为：38
窗口3:买票，票号为：37
窗口3:买票，票号为：36
窗口3:买票，票号为：35
窗口3:买票，票号为：34
窗口3:买票，票号为：33
窗口3:买票，票号为：32
窗口1:买票，票号为：31
窗口1:买票，票号为：30
窗口1:买票，票号为：29
窗口1:买票，票号为：28
窗口1:买票，票号为：27
窗口1:买票，票号为：26
窗口1:买票，票号为：25
窗口1:买票，票号为：24
窗口1:买票，票号为：23
窗口1:买票，票号为：22
窗口1:买票，票号为：21
窗口1:买票，票号为：20
窗口1:买票，票号为：19
窗口1:买票，票号为：18
窗口1:买票，票号为：17
窗口1:买票，票号为：16
窗口1:买票，票号为：15
窗口1:买票，票号为：14
窗口1:买票，票号为：13
窗口1:买票，票号为：12
窗口1:买票，票号为：11
窗口1:买票，票号为：10
窗口1:买票，票号为：9
窗口1:买票，票号为：8
窗口1:买票，票号为：7
窗口1:买票，票号为：6
窗口1:买票，票号为：5
窗口1:买票，票号为：4
窗口1:买票，票号为：3
窗口1:买票，票号为：2
窗口1:买票，票号为：1

Process finished with exit code 130

在这里插入图片描述

1.4.4同步机制中的锁

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

1.4.5同步的范围

  1. 如何找问题，即代码是否存在线程安全？（非常重要）

（1）明确哪些代码是多线程运行的代码
（2）明确多个线程是否有共享数据
（3）明确多线程运行代码中是否有多条语句操作共享数据

  1. 如何解决呢？（非常重要）

对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
即所有操作共享数据的这些语句都要放在同步范围中

  1. 切记：

范围太小：没锁住所有有安全问题的代码
范围太大：没发挥多线程的功能。

1.4.6释放锁的操作

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

1.4.7不会释放锁的操作

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

1.4.8单例设计模式之懒汉式(线程安全)

1.4.8.1使用同步机制将单例模式中的懒汉式改写为线程安全的

1.4.8.1.1方式一：效率稍差
package com.my.java1;

/**
 * @author Redamancy
 * @create 2022-08-07 16:44
 */
class Bank{
    private Bank(){}
    private static Bank instance = null;
    
    public static Bank getInstance(){
        //方式一：效率稍差
        synchronized(Bank.class){
            if(instance == null){
                instance = new Bank();
            }
            return instance;
        }
    }
}

public class BankTest {
}
1.4.8.1.2方式二：效率更高
package com.my.java1;

/**
 * @author Redamancy
 * @create 2022-08-07 16:44
 */
class Bank{
    private Bank(){}
    private static Bank instance = null;

    public static Bank getInstance(){
//        //方式一：效率稍差
//        synchronized(Bank.class){
//            if(instance == null){
//                instance = new Bank();
//            }
//            return instance;
//        }
        //方式二：效率更高
        if(instance==null){
            synchronized(Bank.class){
                if(instance == null){
                    instance = new Bank();
                }
            }
        }
        return instance;
    }
}

public class BankTest {
}

1.4.9线程的死锁问题

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

1.4.9.1演示线程的死锁问题

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

2）我们使用同步时，要避免出现死锁。

package com.my.java1;

/**
 * @author Redamancy
 * @create 2022-08-07 17:22
 */
public class ThreadTest {
    public static void main(String[] args) {
        StringBuffer s1 = new StringBuffer();
        StringBuffer s2 = new StringBuffer();

        new Thread(){
            @Override
            public void run() {
                synchronized(s1){
                    s1.append("a");
                    s2.append("1");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized(s2){
                        s1.append("b");
                        s2.append("2");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }.start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized(s2){
                    s1.append("c");
                    s2.append("3");
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized(s1){
                        s1.append("d");
                        s2.append("4");
                        System.out.println(s1);
                        System.out.println(s2);
                    }
                }
            }
        }).start();
    }
}

在这里插入图片描述

在这里插入图片描述
注意看这里的s1和s2的先后顺序

1.4.10Lock(锁)

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

1.4.10.1解决线程安全问题的方式三：Lock锁 --- JDK5.0新增

package com.my.java1;


import java.util.concurrent.locks.ReentrantLock;

/**
 * @author Redamancy
 * @create 2022-08-07 21:44
 */
class Window implements Runnable{
    private int ticket = 100;
    //1.实例化ReentrantLock
    private ReentrantLock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){

            try {
                //2.调用锁定方法lock()
                lock.lock();
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            } finally {
                //3.调用解锁方法：umlock()
                lock.unlock();

            }
        }
    }
}

public class LockTest{
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();

    }

}

在这里插入图片描述

窗口1:买票，票号为：100
窗口1:买票，票号为：99
窗口1:买票，票号为：98
窗口1:买票，票号为：97
窗口1:买票，票号为：96
窗口1:买票，票号为：95
窗口1:买票，票号为：94
窗口1:买票，票号为：93
窗口1:买票，票号为：92
窗口1:买票，票号为：91
窗口1:买票，票号为：90
窗口1:买票，票号为：89
窗口1:买票，票号为：88
窗口1:买票，票号为：87
窗口1:买票，票号为：86
窗口1:买票，票号为：85
窗口1:买票，票号为：84
窗口1:买票，票号为：83
窗口1:买票，票号为：82
窗口1:买票，票号为：81
窗口1:买票，票号为：80
窗口1:买票，票号为：79
窗口1:买票，票号为：78
窗口1:买票，票号为：77
窗口1:买票，票号为：76
窗口1:买票，票号为：75
窗口1:买票，票号为：74
窗口1:买票，票号为：73
窗口1:买票，票号为：72
窗口1:买票，票号为：71
窗口1:买票，票号为：70
窗口1:买票，票号为：69
窗口2:买票，票号为：68
窗口2:买票，票号为：67
窗口2:买票，票号为：66
窗口2:买票，票号为：65
窗口2:买票，票号为：64
窗口2:买票，票号为：63
窗口2:买票，票号为：62
窗口2:买票，票号为：61
窗口2:买票，票号为：60
窗口2:买票，票号为：59
窗口2:买票，票号为：58
窗口2:买票，票号为：57
窗口2:买票，票号为：56
窗口2:买票，票号为：55
窗口2:买票，票号为：54
窗口2:买票，票号为：53
窗口2:买票，票号为：52
窗口2:买票，票号为：51
窗口2:买票，票号为：50
窗口2:买票，票号为：49
窗口2:买票，票号为：48
窗口2:买票，票号为：47
窗口2:买票，票号为：46
窗口2:买票，票号为：45
窗口2:买票，票号为：44
窗口2:买票，票号为：43
窗口2:买票，票号为：42
窗口2:买票，票号为：41
窗口2:买票，票号为：40
窗口2:买票，票号为：39
窗口2:买票，票号为：38
窗口2:买票，票号为：37
窗口2:买票，票号为：36
窗口2:买票，票号为：35
窗口2:买票，票号为：34
窗口2:买票，票号为：33
窗口2:买票，票号为：32
窗口2:买票，票号为：31
窗口2:买票，票号为：30
窗口2:买票，票号为：29
窗口2:买票，票号为：28
窗口2:买票，票号为：27
窗口2:买票，票号为：26
窗口2:买票，票号为：25
窗口2:买票，票号为：24
窗口2:买票，票号为：23
窗口2:买票，票号为：22
窗口2:买票，票号为：21
窗口2:买票，票号为：20
窗口2:买票，票号为：19
窗口2:买票，票号为：18
窗口2:买票，票号为：17
窗口2:买票，票号为：16
窗口2:买票，票号为：15
窗口2:买票，票号为：14
窗口2:买票，票号为：13
窗口2:买票，票号为：12
窗口2:买票，票号为：11
窗口2:买票，票号为：10
窗口2:买票，票号为：9
窗口2:买票，票号为：8
窗口2:买票，票号为：7
窗口2:买票，票号为：6
窗口2:买票，票号为：5
窗口2:买票，票号为：4
窗口2:买票，票号为：3
窗口2:买票，票号为：2
窗口2:买票，票号为：1

Process finished with exit code 0

1.4.10.2核心代码

class A{
    private final ReentrantLock lock = new ReenTrantLock();
    public void m(){
        try{
            lock.lock();
            //保证线程安全的代码; 
        }finally{
            lock.unlock(); 
        }
    } 
}

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

1.4.11synchronized与Lock的对比

  1. Lock是显式锁（手动开启和关闭锁，别忘记关闭锁），synchronized是隐式锁，出了作用域自动释放
  2. Lock只有代码块锁，synchronized有代码块锁和方法锁
  3. 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）

优先使用顺序：
Lock >同步代码块（已经进入了方法体，分配了相应资源） >同步方法（在方法体之外）

想看完整版的多线程看我发的博客https://blog.csdn.net/Redamancy06/article/details/126229545?spm=1001.2014.3001.5502

文章标签：
Java
安全
算法
调度
设计模式
关键词：
线程synchronized
线程生命周期
Java多线程方法
多线程线程生命周期
Java设计模式线程安全
Redamancy
目录
相关文章
java的细水长流
|
4天前
|
缓存 Java 开发者
Java多线程并发编程：同步机制与实践应用
本文深入探讨Java多线程中的同步机制，分析了多线程并发带来的数据不一致等问题，详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用，结合代码示例展示了如何有效解决竞态条件，提升程序性能与稳定性。
java的细水长流
29 5
muxiaoxi
|
4天前
|
安全 Java 开发者
Java中的多线程编程：从基础到实践
本文深入探讨了Java多线程编程的核心概念和实践技巧，旨在帮助读者理解多线程的工作原理，掌握线程的创建、管理和同步机制。通过具体示例和最佳实践，本文展示了如何在Java应用中有效地利用多线程技术，提高程序性能和响应速度。
muxiaoxi
27 1
哈你真皮
|
5天前
|
Java 数据处理 数据安全/隐私保护
Java处理数据接口方法
Java处理数据接口方法
哈你真皮
15 1
游客762btuqu5wybw666
|
11天前
|
存储 安全 Java
Java多线程编程中的并发容器：深入解析与实战应用####
在本文中，我们将探讨Java多线程编程中的一个核心话题——并发容器。不同于传统单一线程环境下的数据结构，并发容器专为多线程场景设计，确保数据访问的线程安全性和高效性。我们将从基础概念出发，逐步深入到`java.util.concurrent`包下的核心并发容器实现，如`ConcurrentHashMap`、`CopyOnWriteArrayList`以及`BlockingQueue`等，通过实例代码演示其使用方法，并分析它们背后的设计原理与适用场景。无论你是Java并发编程的初学者还是希望深化理解的开发者，本文都将为你提供有价值的见解与实践指导。 --- ####
游客762btuqu5wybw666
25 3
众所周知
|
17天前
|
安全 Java 开发者
深入解读JAVA多线程：wait()、notify()、notifyAll()的奥秘
在Java多线程编程中，`wait()`、`notify()`和`notifyAll()`方法是实现线程间通信和同步的关键机制。这些方法定义在`java.lang.Object`类中，每个Java对象都可以作为线程间通信的媒介。本文将详细解析这三个方法的使用方法和最佳实践，帮助开发者更高效地进行多线程编程。 示例代码展示了如何在同步方法中使用这些方法，确保线程安全和高效的通信。
众所周知
44 9
叫个什么名字
|
20天前
|
存储 安全 Java
Java多线程编程的艺术：从基础到实践####
本文深入探讨了Java多线程编程的核心概念、应用场景及其实现方式，旨在帮助开发者理解并掌握多线程编程的基本技能。文章首先概述了多线程的重要性和常见挑战，随后详细介绍了Java中创建和管理线程的两种主要方式：继承Thread类与实现Runnable接口。通过实例代码，本文展示了如何正确启动、运行及同步线程，以及如何处理线程间的通信与协作问题。最后，文章总结了多线程编程的最佳实践，为读者在实际项目中应用多线程技术提供了宝贵的参考。 ####
叫个什么名字
60 5
ShaFaChuang-36210
|
17天前
|
监控 安全 Java
Java中的多线程编程：从入门到实践####
本文将深入浅出地探讨Java多线程编程的核心概念、应用场景及实践技巧。不同于传统的摘要形式，本文将以一个简短的代码示例作为开篇，直接展示多线程的魅力，随后再详细解析其背后的原理与实现方式，旨在帮助读者快速理解并掌握Java多线程编程的基本技能。 ```java // 简单的多线程示例：创建两个线程，分别打印不同的消息 public class SimpleMultithreading { public static void main(String[] args) { Thread thread1 = new Thread(() -> System.out.prin
ShaFaChuang-36210
36 1
众所周知
|
20天前
|
Java
JAVA多线程通信：为何wait()与notify()如此重要？
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是实现线程间通信的核心机制。它们通过基于锁的方式，使线程在条件不满足时进入休眠状态，并在条件满足时被唤醒，从而确保数据一致性和同步。相比其他通信方式，如忙等待，这些方法更高效灵活。 示例代码展示了如何在生产者-消费者模型中使用这些方法实现线程间的协调和同步。
众所周知
32 3
2G冲浪词条
|
19天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全，提高了并发性能。
2G冲浪词条
28 1
请看我回答~
|
20天前
|
Java UED
Java中的多线程编程基础与实践
【10月更文挑战第35天】在Java的世界中，多线程是提升应用性能和响应性的利器。本文将深入浅出地介绍如何在Java中创建和管理线程，以及如何利用同步机制确保数据一致性。我们将从简单的“Hello, World!”线程示例出发，逐步探索线程池的高效使用，并讨论常见的多线程问题。无论你是Java新手还是希望深化理解，这篇文章都将为你打开多线程的大门。
请看我回答~
32 1

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    Java实现生产者消费者的四种方法
  • 3
    [零基础学JAVA]Java SE应用部分-35.JAVA类集之四
  • 4
    Java控制内存的功力
  • 5
    对象共享：Java并发环境中的烦心事
  • 6
    Java网络编程：实现HTTP模拟器
  • 7
    阿里开发者学院：Java Spring Boot 2.5.x开发实战课程
  • 8
    java-static静态修饰符
  • 9
    关于Eclipse提示Failed to create the java virtual machine问题解决办法
  • 10
    java-subString方法易导致内存溢出
  • 1
    LabVIEW状态机设计模式技术手册和练习
    93
  • 2
    设计模式在Java开发中的应用
    41
  • 3
    写出易维护的代码｜React开发的设计模式及原则
    112
  • 4
    19：Web开发模式与MVC设计模式-Java Web
    108
  • 5
    18：JavaBean简介及其在表单处理与DAO设计模式中的应用-Java Web
    115
  • 6
    JAVA设计模式之结构型模式
    74
  • 7
    【JavaScript 技术专栏】JavaScript 设计模式与实战应用
    87
  • 8
    【初学者慎入】Spring源码中的16种设计模式实现
    357
  • 9
    18个并发场景的设计模式详解，有没有你的盲区
    187
  • 10
    【设计模式学习】单例模式和工厂模式
    79

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月