线程安全问题。文字为主，来源于马士兵赵珊珊老师，代码为辅，自学用，谨慎借鉴，有错误请指正

最新推荐文章于 2024-08-07 07:30:00 发布

想起啥就学啥

最新推荐文章于 2024-08-07 07:30:00 发布

阅读量1.3k

点赞数

分类专栏： JAVA 文章标签： java 多线程开发语言

本文链接：https://blog.csdn.net/pface/article/details/121424602

版权

JAVA 专栏收录该内容

27 篇文章 0 订阅

订阅专栏

Lock接口的lock()和unlock()

Lock和synchronized的区别：

Lock，同步代码块，同步方法的优先使用顺序

同步监视器

在《程序，进程，线程和创建方法》的博客中，第二个经典火车票的案例有问题，是因为线程不安全的原因：多个线程在争抢资源的过程中，很可能会导致资源共享--->一个线程还没执行完，另一个线程就参与进来了开始争抢资源。

如何解决：加个锁

形象理解：去上厕所，人进去之后锁上门，外面的人无论多着急都必须等着锁打开里面的人出来后才能进去

public class TicketThreadSyn implements Runnable{
    static int ticketNumber = 10;

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            // 把具有安全隐患的代码锁住就行了，锁多了会效率低
            synchronized (this) {
                if (ticketNumber > 0) {
                    System.out.println("我在" + Thread.currentThread().getName() + "买到了第" + ticketNumber-- + "张票");
                }
            }
        }
    }
}

    public static void main(String[] args) {
        TicketThreadSyn tts = new TicketThreadSyn();
        Thread tt1 = new Thread(tts,"窗口1");
        tt1.start();
        Thread tt2 = new Thread(tts,"窗口2");
        tt2.start();
        Thread tt3 = new Thread(tts,"窗口3");
        tt3.start();
    }

成功解决

第一个经典火车案例加锁：

形象记忆：在古代上厕所没有锁这个东西，人们会在厕所前面放着红色橙色两个不同颜色水杯，谁上厕所就会把其中一个水杯放到厕所门口。然而有的人只认识其中一种颜色的水杯。当另一种颜色的水杯放在门口的时候，这类人因为不认识，所以仍然会去上厕所，这就造成了抢厕所的问题。所以为了解决，必须只能有一个颜色的水杯并且所有人都认识

public class TicketThreadSynThread extends Thread{
    static int ticketNumber = 50;

    public TicketThreadSynThread() { }

    public TicketThreadSynThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            synchronized (TicketThreadSynThread.class){// 无论多少个对象，都认识这个类的字节码
                if(ticketNumber > 0){
                    System.out.println("我在" + this.getName() + "买到了第" + ticketNumber-- +"张票");
                }
            }
        }
    }
}

    public static void main(String[] args) {
        TicketThreadSynThread tt1 = new TicketThreadSynThread("窗口1");
        tt1.start();
        TicketThreadSynThread tt2 = new TicketThreadSynThread("窗口2");
        tt2.start();
        TicketThreadSynThread tt3 = new TicketThreadSynThread("窗口3");
        tt3.start();
    }

实现Runnable接口，锁的里面用this，是因为创建的线程对象就tts一个，那调用run()方法对象也只有一个tts，这一个对象用的就是这一把确定的锁，所以锁里面可以用this关键字来表示。而继承Thread类的，创建的是tt1，tt2，tt3三个线程对象，这三个对象分别配置的是不同的锁，假设tt1认识这把锁，则tt2和tt3就不认识，那么这把锁就没有任何意义，即this关键字在这里不起作用，而测试类中无论创建了多少线程，字节码信息却只有一个，所以每一个线程都认识这把锁。

同步监视器总结：

总结一：认识同步监视器：synchronized(同步监视器){ }

1.必须是引用数据类型

2.可以创建一个专门的同步监视器，没有任何业务含义

3.一般使用共享资源做同步监视器即可

4.在同步代码块中不能改变同步监视器对象的引用

5.尽量不要用String和包装了Integer做同步监视器

6.建议使用final修饰同步监视器

总结二：同步代码块的执行过程

1.第一个线程来到同步代码块，发现同步监视器open状态，需要close然后执行其中代码

2.第一个线程执行过程中，发生了线程切换（阻塞就绪），第一个线程是去了CPU，但是没有开锁open

3.第二个线程获取了CPU，来到同步代码块，发现同步监视器close状态，无法执行其中的代码，第二个线程也进入阻塞状态

4.第一个线程再次获取CPU，接着执行后续的代码；同步代码块执行完毕，释放锁open

5.第二个线程也再次获取CPU，来到了同步代码块，发现同步监视器open状态，拿到所并且上锁，由阻塞状态进入就绪状态，在进入运行状态，重复第一个线程的处理过程（加锁）

强调：同步代码块中能发生CPU切换吗？能！但后续的被执行线程也无法执行同步代码块，因为锁仍旧是close

总结三：

1.多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的代码块，其他线程无法访问其中的任何一个代码块

2.多个代码块使用了同一个同步监视器（锁），锁住一个代码块的同时，也锁住所有使用该锁的代码块，但是没有锁住使用其他同步监视器的代码块，其他线程有机会访问其他同步监视器的代码块

同步方法

public class TTSynT2 extends Thread{
    static int ticketNumber = 10;

    public TTSynT2() { }

    public TTSynT2(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            buyTicket();
        }
    }

    public static synchronized void buyTicket(){
        if(ticketNumber > 0){
            System.out.println("我在" + Thread.currentThread().getName() + "买到了第" + ticketNumber-- +"张票");
        }
    }
}

    public static void main(String[] args) {
        TTSynT2 tt1 = new TTSynT2("窗口1");
        tt1.start();
        TTSynT2 tt2 = new TTSynT2("窗口2");
        tt2.start();
        TTSynT2 tt3 = new TTSynT2("窗口3");
        tt3.start();
    }

同步方法加入staitc，是因为tt1，tt2，tt3，仍旧是三个不同的线程对象，每次run()执行时，都会分三次调用同步方法，那这个锁依旧是毫无意义，加上static后，就可以保证锁唯一，这样就能使用了

public class TTSynR2  implements Runnable{
    static int ticketNumber = 10;

    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {
            buyTicket();
        }
    }

    public synchronized void buyTicket(){
            if (ticketNumber > 0) {
                System.out.println("我在" + Thread.currentThread().getName() + "买到了第" + ticketNumber-- + "张票");
            }
    }
}

public class SynRunnableTest {

    public static void main(String[] args) {
        TTSynR2 tts = new TTSynR2();
        Thread tt1 = new Thread(tts,"窗口1");
        tt1.start();
        Thread tt2 = new Thread(tts,"窗口2");
        tt2.start();
        Thread tt3 = new Thread(tts,"窗口3");
        tt3.start();
    }
}

不加static是因为线程对象只有tts一个

同步方法总结

1.不要讲run()定义为同步方法

2.非静态同步方法的同名监视器是this；静态同步方法的同名监视器是类名.class字节码信息对象

3.同步代码块的效率要高于同步方法。原因：同步方法是将线程挡在了方法的外部，而同步代码块锁将线程挡在了代码块的外部，但是确实方法的内部

4.同步方法的锁是this，一旦锁住了这一个方法，就锁住了所有的同步方法；同步代码块只是锁住使用该同步监视器的代码块，而没有锁住其他监视器的代码块

Lock接口的lock()和unlock()

public class TTSynR3 implements Runnable{
    static int ticketNumber = 10;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        for (int i = 1; i <= 100; i++) {

            try {
                lock.lock();
                // 把具有安全隐患的代码锁住就行了，锁多了会效率低
                if (ticketNumber > 0) {
                    System.out.println("我在" + Thread.currentThread().getName() + "买到了第" + ticketNumber-- + "张票");
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }
    }
}


    public static void main(String[] args) {
        TTSynR3 tts = new TTSynR3();
        Thread tt1 = new Thread(tts,"窗口1");
        tt1.start();
        Thread tt2 = new Thread(tts,"窗口2");
        tt2.start();
        Thread tt3 = new Thread(tts,"窗口3");
        tt3.start();
    }