23、java 多线程之二：同步代码块解决线程安全(方式一)、同步方法解决线程安全(方式二)、两种方式与Thread 类及Runnable 接口混搭使用的利弊和问题(经典案例)

于 2024-12-23 11:11:31 发布
阅读量862 收藏 9
点赞数 37
CC 4.0 BY-SA版权
分类专栏： Java学习 文章标签： java 线程安全 后端 经验分享 同步代码块 同步方法 经典案例
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43405300/article/details/144154877

java 多线程之二：

Ⅰ、解决多线程线程安全的方式一：同步代码块

1、同步代码块或方法解决线程安全流程：

其一、多线程代码存在线程安全问题的描述：

// 22、java 多线程之一中，创建多线程可能存在的如下问题：



 * 例子：创建三个窗口卖票，总票数为 100 张.使用实现 Runnable 接口的方式
 *
 *
 * 1.问题：卖票过程中，出现了重票、错票 --> 出现了线程的安全问题
 *
 * 2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票导致的问题;
 *
 * 3.如何解决：当一个线程 a 在操作 ticket 的时候，其他线程不能参与进来。直到线程 a 操作完 ticket 时，其他
 *            线程才可以开始操作 ticket。这种情况即使线程 a 出现了阻塞，也不能被改变。
 *
 *
 * 4.在 Java 中，我们通过同步机制，来解决线程的安全问题。

其二、两种解决线程安全的流程及优缺点描述：

// 解决多线程线程安全的两种方式：同步代码块和同步方法



 *  方式一：同步代码块
 *
 *   synchronized(同步监视器){
 *      //需要被同步的代码
 *
 *   }
 *
 *  说明：1.操作共享数据的代码，即为需要被同步的代码。  -->不能包含代码多了，也不能包含代码少了。
 *       2.共享数据：多个线程共同操作的变量。比如：ticket 就是共享数据。
 *       3.同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。
 *          要求：多个线程必须要共用同一把锁(即：同步监视器，锁，的要求)。
 *
 *       补充：在实现 Runnable 接口创建多线程的方式中，我们可以考虑使用 this 充当同步监视器。
 *
 *
 *  方式二：同步方法。
 *     如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
 *
 *
 *
 *  5.同步的方式，解决了线程的安全问题。---好处
 *    操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。 ---局限性

其二、代码为：



class Window1 implements Runnable{

    private int ticket = 100;
//    Object obj = new Object();//线程安全，因为多个线程使用的是同一把锁;
//    Dog dog = new Dog();
    @Override
    public void run() {
//        Object obj = new Object();//线程不安全，因为多个线程使用的不是同一把锁(即：每个线程使用的是各自的锁而不是同一把锁);
        while(true){
            synchronized (this){//此时的this: 唯一的 Window1 的对象   //方式二：synchronized (dog) {
                                //此时的 this 是当前对象(即：this 是对象，是 Window1 的对象 w);

                if (ticket > 0) {

                    //sleep 增大了 cpu 切换线程的概率(因为当前 cpu 执行的线程被阻塞);
                    //sleep 的使用，同时也提升了错票的概率(0/-1), 并不是说 sleep 导致错票的出现而是错票本来就存在，只是提升了错票的概率而已;
                    //注意：是指未使用方案来解决线程安全的情况下，才会出现错票的情况(即：0/-1 的情况，已自测)，若已解决线程安全问题，不会出错票问题;
                    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{

}

其三、截图为：

// 三个窗口共卖 100 张票，不会出现两个及以上对象同时卖一张票的问题，不涉及线程安全性问题(即：该线程是安全的);

在这里插入图片描述

在这里插入图片描述

2、同步代码块解决继承 Thread 的线程安全案例1：三个窗口卖100张票

其一、描述：



 * 使用同步代码块解决继承 Thread 类的方式的线程安全问题
 *
 * 例子：创建三个窗口卖票，总票数为 100 张.使用继承 Thread 类的方式
 *
 * 说明：在继承 Thread 类创建多线程的方式中，慎用 this 充当同步监视器(即：具体问题具体分析，注意唯一性)，考虑使用当前类充当同步监视器。

其二、代码为：



class Window2 extends Thread{


    private static int ticket = 100;

    private static Object obj = new Object();

    @Override
    public void run() {

        while(true){
            //正确的
//            synchronized (obj){//线程不安全，因为多个线程使用的不是同一把锁(即：每个线程使用的是各自的 obj 锁而不是同一把锁);
                                 //线程安全，由于 obj 前面加了 static 后，就导致多个对象就使用的是同一个 obj 锁;

            synchronized (Window2.class){//Class clazz = Window2.class, Window2.class 只会加载一次(即：意味着其只有一个)
                                         //从侧面印证：类也是对象(因为锁的要求必须是对象);

                //错误的方式：this 代表着 t1,t2,t3 三个对象
//              synchronized (this){//此时的 this 是当前对象(即：this 是对象，是 Window2 的对象 t1.t2,t3 并不唯一，因此锁就不唯一);

                if(ticket > 0){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(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();

    }
}

其三、截图为：

// 三个窗口共卖 100 张票，不会出现两个及以上对象同时卖一张票的问题，不涉及线程安全性问题(即：该线程是安全的);

在这里插入图片描述

在这里插入图片描述

Ⅱ、解决多线程线程安全的方式二：同步方法

1、同步方法解决实现 Runnable 接口的线程安全案例1：三个窗口卖100张票

其一、描述：



 * 使用同步方法解决实现 Runnable 接口的线程安全问题
 *
 *
 *  关于同步方法的总结：
 *
 *  1. 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
 *
 *  2. 非静态的同步方法，同步监视器是：this
 *     静态的同步方法，同步监视器是：当前类本身

其二、代码为：



class Window3 implements Runnable {

    private int ticket = 100;

    @Override
    public void run() {
        while (true) {

            show();
//            //此下代码可作为程序暂停的标记
//            if(ticket <= 0){
//                break;
//            }
        }
    }

    private synchronized void show(){//同步监视器：this(即：此时有默认的锁，而不是没锁)
        //synchronized (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();
    }

}

其三、截图为：

// 三个窗口共卖 100 张票，不会出现两个及以上对象同时卖一张票的问题，不涉及线程安全性问题(即：该线程是安全的);

在这里插入图片描述

在这里插入图片描述

2、同步方法解决实现继承 Thread 的线程安全案例2：三个窗口卖100张票

其一、描述：


 * 使用同步方法处理继承 Thread 类的方式中的线程安全问题

其二、代码为：



class Window4 extends Thread {


    private static int ticket = 100;

    @Override
    public void run() {

        while (true) {

            show();
//            //此下代码可作为程序暂停的标记
//            if(ticket <= 0){
//                break;
//            }
        }

    }
    private static synchronized void show(){//同步监视器：Window4.class(一定不是 this，因为在静态里也不能调 this)
        //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
                                            //只能在加上 static 关键字后，才是使用同步方法解决线程安全问题的方式;
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
            //此时表示 Thread.currentThread().getName() 方法是静态的，而 getName() 方法非静态;
            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();

    }
}

其三、截图为：

// 三个窗口共卖 100 张票，不会出现两个及以上对象同时卖一张票的问题，不涉及线程安全性问题(即：该线程是安全的);

在这里插入图片描述
在这里插入图片描述

3、同步代码块或方法解决线程安全案例3：单例模式中的懒汉式

其一、描述：


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

其二、代码为：



public class BankTest {

}

class Bank{

    private Bank(){}

    private static Bank instance = null;

    //解决线程安全的一种方式：
    //此时已经就是线程安全了，因为其是同步方法，且该同步方法的锁是：Bank.class(因为：静态同步方法的锁是当前类本身，因为类本身也充当了对象)
//    public static synchronized Bank getInstance(){
//        if(instance == null){
//            instance = new Bank();
//        }
//        return instance;
//    }



    public static Bank getInstance(){


        //方式一：效率稍差(并不是因为同步导致的效率差，而是本身)
//        synchronized (Bank.class) {//改写法以上述的 public static synchronized Bank getInstance(){} 是一致的;
//            if(instance == null){
//
//                instance = new Bank();
//            }
//            return instance;
//        }


        //方式二：效率更高(只要一个线程 instance = new Bank(); 成功，那么后面大多数的线程就不需要进入线程安全的判断)
        if(instance == null){

            synchronized (Bank.class) {
                if(instance == null){

                    instance = new Bank();
                }

            }
        }
        return instance;
    }

}

Ⅲ、小结：

其一、哪里有不对或不合适的地方，还请大佬们多多指点和交流！
其二、若有转发或引用本文章内容，请注明本博客地址(直接点击下面 url 跳转) https://blog.csdn.net/weixin_43405300,创作不易，且行且珍惜！

评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

狮子座的男孩

如果可以，请我喝杯咖啡吧！

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值