（二）synchronized关键字（2）

最新推荐文章于 2022-10-14 14:35:04 发布

dabing2032

最新推荐文章于 2022-10-14 14:35:04 发布

阅读量91

点赞数

分类专栏： ----【并发编程】

原文链接：https://blog.csdn.net/qq_34337272/article/details/79670775

版权

----【并发编程】专栏收录该内容

9 篇文章 0 订阅

订阅专栏

(2) synchronized同步语句块

一 synchronized方法的缺点

使用synchronized关键字声明方法，有时候是有很大的弊端。比如我们有两个线程，一个线程A调用同步方法后获取锁，那么另一个线程B就需要等待A执行完，但是如果说A执行的是一个很费时间的任务就会很耗时。

先来看一个暴露synchronized方法的缺点实例，然后再看看如何通过synchronized同步语句块解决这个问题。

public class Task {

    private String getData1;
    private String getData2;

    public synchronized void doLongTimeTask() {
        try {
            System.out.println("begin task");
            Thread.sleep(3000);
            System.out.println("等待3秒");
            getData1 = "长时间处理任务后从远程返回的值1 threadName="
                    + Thread.currentThread().getName();
            getData2 = "长时间处理任务后从远程返回的值2 threadName="
                    + Thread.currentThread().getName();
            System.out.println(getData1);
            System.out.println(getData2);
            System.out.println("end task");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

public class CommonUtils {

    public static long beginTime1;
    public static long endTime1;

    public static long beginTime2;
    public static long endTime2;
}

public class MyThread1 extends Thread {
    private Task task;
    public MyThread1(Task task) {
        super();
        this.task = task;
    }
    @Override
    public void run() {
        super.run();
        CommonUtils.beginTime1 = System.currentTimeMillis();
        task.doLongTimeTask();
        CommonUtils.endTime1 = System.currentTimeMillis();
    }
}

public class MyThread2 extends Thread {
    private Task task;
    public MyThread2(Task task) {
        super();
        this.task = task;
    }
    @Override
    public void run() {
        super.run();
        CommonUtils.beginTime2 = System.currentTimeMillis();
        task.doLongTimeTask();
        CommonUtils.endTime2 = System.currentTimeMillis();
    }
}
public class Run {

    public static void main(String[] args) {
        Task task = new Task();

        MyThread1 thread1 = new MyThread1(task);
        thread1.start();

        MyThread2 thread2 = new MyThread2(task);
        thread2.start();

        try {
            Thread.sleep(10000);
            System.out.println("等待10秒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        long beginTime = CommonUtils.beginTime1;
        if (CommonUtils.beginTime2 < CommonUtils.beginTime1) {
            beginTime = CommonUtils.beginTime2;
        }

        long endTime = CommonUtils.endTime1;
        if (CommonUtils.endTime2 > CommonUtils.endTime1) {
            endTime = CommonUtils.endTime2;
        }

        System.out.println("耗时：" + ((endTime - beginTime) / 1000));
    }
}

运行结果：

begin task
等待3秒
长时间处理任务后从远程返回的值1 threadName=Thread-0
长时间处理任务后从远程返回的值2 threadName=Thread-0
end task
begin task
等待3秒
长时间处理任务后从远程返回的值1 threadName=Thread-1
长时间处理任务后从远程返回的值2 threadName=Thread-1
end task
等待10秒
耗时：6

从运行时间上看，synchronized方法的问题就很明显。可以使用synchronized同步块来解决这个问题。但是要注意synchronized同步块的使用，如果synchronized同步块使用不好的话并不会带来效率的提升。

二 synchronized（this）同步代码块的使用

修改上例中的Task.java如下：

public class Task {

    private String getData1;
    private String getData2;

    public void doLongTimeTask() {
        try {
            System.out.println("begin task");
            Thread.sleep(3000);

            String privateGetData1 = "长时间处理任务后从远程返回的值1 threadName="
                    + Thread.currentThread().getName();
            String privateGetData2 = "长时间处理任务后从远程返回的值2 threadName="
                    + Thread.currentThread().getName();

            synchronized (this) {
                getData1 = privateGetData1;
                getData2 = privateGetData2;
            }

            System.out.println(getData1);
            System.out.println(getData2);
            System.out.println("end task");
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

运行结果：

begin task
begin task
等待3秒
等待3秒
长时间处理任务后从远程返回的值1 threadName=Thread-0
长时间处理任务后从远程返回的值2 threadName=Thread-1
长时间处理任务后从远程返回的值1 threadName=Thread-1
长时间处理任务后从远程返回的值2 threadName=Thread-1
end task
end task
等待10秒
耗时：3

从上面代码可以看出，当一个线程访问一个对象的synchronized同步块时，另一个线程仍然可以访问非synchronized同步代码块。

时间虽然缩短了，但是大家考虑一下synchronized代码块真的是同步的吗？它真的持有当前调用对象的锁吗？

是的。不存在synchronized代码块就异步执行，在synchronized代码块中就是同步执行。

三 synchronized（object）代码块间使用

public class MyObject {
}

public class Service {

    public void testMethod1(MyObject object) {
        synchronized (object) {
            try {
                System.out.println("testMethod1 ____getLock time="
                        + System.currentTimeMillis() + " run ThreadName="
                        + Thread.currentThread().getName());
                Thread.sleep(2000);
                System.out.println("testMethod1 releaseLock time="
                        + System.currentTimeMillis() + " run ThreadName="
                        + Thread.currentThread().getName());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


public class ThreadA extends Thread {

    private Service service;
    private MyObject object;

    public ThreadA(Service service, MyObject object) {
        super();
        this.service = service;
        this.object = object;
    }

    @Override
    public void run() {
        super.run();
        service.testMethod1(object);
    }
}


public class ThreadB extends Thread {
    private Service service;
    private MyObject object;

    public ThreadB(Service service, MyObject object) {
        super();
        this.service = service;
        this.object = object;
    }

    @Override
    public void run() {
        super.run();
        service.testMethod1(object);
    }

}


public class Run1_1 {

    public static void main(String[] args) {
        Service service = new Service();
        MyObject object = new MyObject();

        ThreadA a = new ThreadA(service, object);
        a.setName("a");
        a.start();

        ThreadB b = new ThreadB(service, object);
        b.setName("b");
        b.start();
    }
}

运行结果：

testMethod1 ____getLock time=1572336730333 run ThreadName=a
等待2秒
testMethod1 releaseLock time=1572336732334 run ThreadName=a
testMethod1 ____getLock time=1572336732334 run ThreadName=b
等待2秒
testMethod1 releaseLock time=1572336734334 run ThreadName=b

可以看出，两个线程使用了同一个“对象监视器”，所以运行结果就是同步的

那么，如果使用不同的对象监视器会出现什么效果呢？

修改Run1_1.java如下：

public class Run1_2 {

    public static void main(String[] args) {
        Service service = new Service();
        MyObject object1 = new MyObject();
        MyObject object2 = new MyObject();

        ThreadA a = new ThreadA(service, object1);
        a.setName("a");
        a.start();

        ThreadB b = new ThreadB(service, object2);
        b.setName("b");
        b.start();
    }
}

运行结果：

testMethod1 ____getLock time=1572336996093 run ThreadName=a
testMethod1 ____getLock time=1572336996094 run ThreadName=b
等待2秒
testMethod1 releaseLock time=1572336998094 run ThreadName=b
等待2秒
testMethod1 releaseLock time=1572336998095 run ThreadName=a

可以看出，两个线程使用了不用的“对象监视器”，所以运行结果就不是同步的

四 synchronized代码块间的同步性

当一个对象访问synchronized(this)代码块时，其他线程对同一个对象中其他synchronized(this)代码块的访问就将被阻塞，这说明synchronized(this)代码块使用的“对象监视器”是一个。也就是说和synchronized方法一样，synchronized(this)代码块也是锁定当前对象的。

另外通过上面的例子，可以得出两个结论：

其他线程执行对象中synchronized同步方法和synchronized(this)代码块时呈现同步效果。
如果两个线程使用同一个“对象监视器”，运行结果同步。

五静态同步synchronized方法与synchronized(class)代码块

synchronized关键字加到static静态方法和synchronized(class)代码块上都是给Class类上锁，而synchronized关键字加到非static静态方法上是给对象上锁。

public class Service {

    public static void printA() {
        synchronized (Service.class) {
            try {
                System.out.println(
                        "线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printA");
                Thread.sleep(3000);
                System.out.println(
                        "线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printA");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    synchronized public static void printB() {
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printB");
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printB");
    }

    synchronized public void printC() {
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "进入printC");
        System.out.println("线程名称为：" + Thread.currentThread().getName() + "在" + System.currentTimeMillis() + "离开printC");
    }

}


public class ThreadA extends Thread {
    private Service service;
    public ThreadA(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.printA();
    }
}


public class ThreadB extends Thread {
    private Service service;
    public ThreadB(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.printB();
    }
}


public class ThreadC extends Thread {
    private Service service;
    public ThreadC(Service service) {
        super();
        this.service = service;
    }
    @Override
    public void run() {
        service.printC();
    }
}


public class Run {
    public static void main(String[] args) {
        Service service = new Service();
        ThreadA a = new ThreadA(service);
        a.setName("A");
        a.start();

        ThreadB b = new ThreadB(service);
        b.setName("B");
        b.start();

        ThreadC c = new ThreadC(service);
        c.setName("C");
        c.start();
    }
}

运行结果：

线程名称为：A在1572337840451进入printA
线程名称为：C在1572337840452进入printC
线程名称为：C在1572337840452离开printC
等待3秒
线程名称为：A在1572337843452离开printA
线程名称为：B在1572337843452进入printB
线程名称为：B在1572337843452离开printB

从运行结果可以看出：

静态同步synchronized方法与synchronized(class)代码块持有的锁一样，都是Class锁，Class锁对对象的所有实例起作用。

synchronized关键字加到非static方法上持有的是对象锁。

线程A、B和线程C持有的锁不一样，所以A和B同步运行，但是和C运行不同步。

六数据类型String的常量池属性

在JVM中具有String常量池缓存的功能

	String s1 = "a";
    String s2 = "a";
    System.out.println(s1==s2);//true

上面代码输出为true.这是为什么呢？

字符串常量池中的字符串只存在一份！即执行完第一行代码后，常量池中已存在 “a”，那么s2不会在常量池中申请新的空间，而是直接把已存在的字符串内存地址返回给s2。

因为数据类型String的常量池属性，所以synchronized（string）在使用时，某些情况下会出现一些问题，
比如两个线程运行

synchronized(“abc”)｛
｝

和
synchronized(“abc”)｛
｝

修饰的方法时，这两个线程持有相同的锁，导致某一时刻只有一个线程能运行。所以尽量不要使用synchronized（string），而使用synchronized（onject）。

dabing2032

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
（二）synchronized关键字（2）

1111
复制链接

扫一扫

专栏目录

（二）synchronized关键字（2）

(2) synchronized同步语句块

一 synchronized方法的缺点

二 synchronized（this）同步代码块的使用

三 synchronized（object）代码块间使用

四 synchronized代码块间的同步性

五 静态同步synchronized方法与synchronized(class)代码块

六 数据类型String的常量池属性

“相关推荐”对你有帮助么？

五静态同步synchronized方法与synchronized(class)代码块

六数据类型String的常量池属性