多线程（二）同步问题(synchronized 与 Lock 的异同，sleep () 和 wait () 的异同)

最新推荐文章于 2023-01-29 00:50:00 发布

布莱斯Bryce

最新推荐文章于 2023-01-29 00:50:00 发布

阅读量442

点赞数

分类专栏：多线程文章标签： java 多线程同步

本文链接：https://blog.csdn.net/qq_42010877/article/details/110817381

版权

多线程专栏收录该内容

3 篇文章 0 订阅

订阅专栏

线程同步

优点：同步的方式，解决了线程的安全问题。

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

操作共享数据的代码，即为需要被同步的代码。

共享数据：多个线程共同操作的变量。

同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。

要求：多个线程必须要共用同一把锁。在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。

1. 关键字：synchronized

同步方式一：同步代码块

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

Runnable接口，同步监视器的选择：

public class Test implements Runnable{
	private Object obj = new Object();
    public  void run() {
        while(true){
            //1.当前类
            synchronized (Test.class){
                ...
            }
            //2.实例化后的对象，this
            synchronized (this){
                ...
            }
            //3.其他任意对象，例：Object();
            synchronized (obj){
                ...
            }
        }
    }
}

继承Thread，同步监视器的选择

class MyThread extends Thread {
    private static Object obj = new Object();
    private static int count=10;
    public  void run() {
        while(true){
            //1.当前类
            synchronized (MyThread.class){
                if (count>=0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+":"+count);
                    count--;
                }else {
                    break;
                }
            }
            //2.实例化后的对象，this，new了多个对象m1,m2,m3,此处为错误写法
            synchronized (this){}
            //3.其他任意对象，例：Object();需要关键字static
            synchronized (obj){}
        }
    }
}
public class Test {
    public static void main(String[] args) {
        MyThread m1 = new MyThread();
        MyThread m2 = new MyThread();
        MyThread m3 = new MyThread();
        m1.start();
        m2.start();
        m3.start();
    }
}

注意事项：在继承Thread中，谨慎选择this来充当同步监视器，可以优先当前类。

不能包含代码多了，也不能包含代码少了。

public  void run() {
    //这里同步代码把while循环包含进去了
	synchronized (obj){
        while(true){
            if (count>=0){
                try {
                	Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+":"+count);
                count--;
            }else {
                break;
            }
        }
    }
}

结果：

Thread-0:10
Thread-0:9
Thread-0:8
Thread-0:7
Thread-0:6
Thread-0:5
Thread-0:4
Thread-0:3
Thread-0:2
Thread-0:1
Thread-0:0

从结果可以看出如果包多了，多个线程操作一个数据，最后结果就是一个线程把所有的事情做完了
如果包少了，数据就会产生异常

同步方式二：同步方法

Runnable接口

此处synchronized是可以用在run()上，但是会多包含 while循环，所以此处把只需同步的代码封装成一个方法，此处的同步监视器是this

class MyRunnable implements Runnable {
    private int count=10;
    public void run() {
        while(true){
            if (count<0){
                break;
            }
            show();
        }
    }
    public synchronized void show(){
        if (count>=0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+count);
            count--;
        }
    }
}

继承Thread

因为使用继承Thread实现，在多线程下，会有new多个对象，需要给加了synchronized的方法加上static，让类只加载一次，此处的同步监视器是当前类本身，MyThread.class

class MyThread extends Thread {
    private static int count=10;
    public void run() {
        while(true){
            if (count<0){
                break;
            }
            show();
        }
    }
    public static synchronized void show(){
        if (count>=0){
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+":"+count);
            count--;
        }
    }
}

同步方法仍然涉及到同步监视器，只是不需要我们显示申明

延伸：单例模式之懒汉式

众所周知，懒汉式是非线程安全的，因为懒汉式是在第一次调用的时候才初始化，在多线程下，会导致多个线程调用被多次初始化，所以在多线程下需要给懒汉式加锁

整体而言使懒汉式变为了单线程了，效率稍微差一些

原因：第一个线程获取到锁后，使得后面所有的线程都在等待获取锁

public class Singleton {
    
    private static Singleton instance = null;
    
    private Singleton (){}
    
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

双重检查效率更高

原因：如果前面有线程已经初始化了，这样就让后面的线程直接跳过获取锁的阶段，效率更高

public class Singleton {
    
    private static Singleton instance = null;
    
    private Singleton (){}
    
    public static  Singleton getInstance() {
        if(instance == null){
            synchronized(Singleton.class){
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        } 
        return instance;
    }
}

2. Lock锁

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

优先使用顺序：

Lock -> 同步代码块（已经进入了方法体，分配了相应资源） -> 同步方法（在方法体之外）

面试题：synchronized 与 Lock的异同？

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

不同：1.synchronized是关键字，属于JVM层面，Lock是jdk5以后的一个具体的类，属于API层面

2.synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
ReentrantLock需要手动的启动同步（lock()），同时结束同步也需要手动的实现（unlock()）

3.synchronized不可中断，除非抛出异常或者正常运行完成
ReentrantLock 可中断，1.设置超时方法trylock(long time,TimeUnit unit)
2.lockInterruptibly()放代码块中，调用interrupt()方法可中
4.synchronized非公平锁
ReentrantLock 两者都可以，默认非公平锁

5.synchronized只能随机唤醒或者唤醒全部线程
ReentrantLock 可以用Condition进行分组唤醒需要唤醒的线程，可以精确唤醒

面试题：如何解决线程安全问题？有几种方式

Lock，同步代码块，同步方法