synchronized 关键字 用法

作者: fupeng | 来源:发表于2017-05-07 15:34 被阅读83次

在Java的集合类中,有些是同步不安全的,如HashMap,有些是同步安全的,如HashTable,Vector。
查看源码会发现,这些所谓同步安全的集合,其实现方式 就是 通过在某些方法上,如add,增加synchronized修饰。然后同步就实现了。

同步是什么,同步就是排队,比如公共电话亭打电话,一个电话,现在来了3个人,同步就是说第一个人打完了,第二个人再上,之后第三个人再上。

需要同步的原因是因为有并发,有多个线程,单线程永远没有同步的问题,那本身就是同步的。
多线程也未必就有同步的需要,当众多线程 对于 观察对象,不进行干扰的话,并发也不需要同步,比如看直播,1个人看直播,和10万人看直播,你们只是看的话,是没有并发问题的,不需要同步,只需要把直播画面,拷贝10万份给每个人就可以了。

但下面这种情况就有问题了,10个人在看一个主播直播,其中3个人希望主播换一首歌,换成自己喜欢的,如果这三个请求同时提出,那么主播该怎么办。
如果三首同时放,那不可能,也没法听。
如果随便忽略掉请求,也不算完美的解决办法。
最后的办法只能是 把并行的需求,串行化,一个一个来。

所以同步说白一点,就是排队,一个一个来。

那一个一个来有什么问题呢? 这不又成单线程了吗

所以这其中的问题是
1,单线程,正确,但一个一个来,处理的太慢。
2,多线程,并发,同时做,肯定速度快,但某些点上,有可能出现错误。

同步就要求,即快,又正确。这就是难点,难在,需要分析出,
在这件事情中,哪些区域是可以并发,也不会出问题的,哪些区域是不能并发,还是要排队的。

所以同步就是 多线程+单线程的组合。

用关键字synchronized,首先要分析出,要对谁进行同步,先看个错误例子,这里面用了synchronized,还是没有达到同步的效果。


class Task implements Runnable{

    synchronized void add(){

            int tmp = TestMain.i;
            tmp = tmp + 1;
            TestMain.i = tmp;
    }

    public void run() {
        //每个线程会增加50次
        for(int i=0;i<50;i++){
            add();
        }
    }
}

public class TestMain {

    static int i=0;
    static Object o = new Object();

    public static void main(String[] args) throws InterruptedException {

//        创建100个线程
        for(int i=0;i<100;i++){
            Thread t =  new Thread(new Task());
            t.start();
        }

        Thread.sleep(1000);
        System.out.println(i);

    }
}

某一次输出为
4969

这个程序会创建100个线程,每个线程执行的任务是 对 变量i增加50次, 所以我期望的结果,i最后变成5000了,但事与愿违
这个程序基本每次输出都不一样,但都小于5000.

原因就处在add()方法上, 但我已经给这个方法 加上synchronized关键字了,为什么还是同步不了呢?

这个问题困扰了我很久,直到---
因为我没搞明白一个问题,synchronized是给谁加锁的。
锁在哪儿, Java中,每个对象都是锁,包括实例出来的对象,类本身。

现在回头看这个程序, 我把synchronized加再一个 普通方法上, 这时 锁就是 实例化的Task对象, 它能实现的效果是, 多个线程,在操作这个实例的 add方法时,保证它们是排队进行的。
可我的程序中
Thread t = new Thread(new Task()); 这段代码, 在创建每个线程时,都新创建 了一个 新的Task实例, 等于是100个线程,创建了100把锁,足球场100个人,发了100个球,各玩各的,根本不同竞争。 那么怎么修改呢
简单,只创建一个 Task实例,给100个线程去玩,到时候,自然会竞争add方法的, 代码修改如下


class Task implements Runnable{

    synchronized void add(){

            int tmp = TestMain.i;
            tmp = tmp + 1;
            TestMain.i = tmp;
    }

    public void run() {
        //每个线程会增加50次
        for(int i=0;i<50;i++){
            add();
        }
    }
}

public class TestMain {

    static int i=0;
    static Object o = new Object();

    public static void main(String[] args) throws InterruptedException {
        //只创建一个Task ,然后传给100个线程。
        Task  task = new Task();
//        创建100个线程
        for(int i=0;i<100;i++){
            Thread t =  new Thread(task);
            t.start();
        }

        Thread.sleep(1000);
        System.out.println(i);

    }
}

输出
5000

输出5000, 符合预期。 这是synchronized的一种情况,对普通方法加锁,锁是该类实例后的 对象。

synchronized还有两种用法, 修饰静态方法, 和 修饰代码块。

下面的代码是 同步静态方法 的 例子,将原来的add方法改成static的了


class Task implements Runnable{

    synchronized static void add(){

            int tmp = TestMain.i;
            tmp = tmp + 1;
            TestMain.i = tmp;
    }

    public void run() {
        //每个线程会增加50次
        for(int i=0;i<50;i++){
            add();
        }
    }
}

public class TestMain {

    static int i=0;
    static Object o = new Object();

    public static void main(String[] args) throws InterruptedException {
        //只创建一个Task ,然后传给100个线程。

//        创建100个线程
        for(int i=0;i<100;i++){
            Thread t =  new Thread(new Task());
            t.start();
        }

        Thread.sleep(1000);
        System.out.println(i);

    }
}

输出
5000  符合预期。

在这个例子中, 100个线程 创建了100个Task实例, 但并没有出现 并发的错误, 原因是 add是静态方法, 和具体的实例无关, 即使new100个实例,也是用的一个方法, synchronized修饰静态方法, 对应的锁是这个静态方法的类,所以 同步没有问题。

第三种情况, synchronized代码块


class Task implements Runnable{

    void add(){
        synchronized (Task.class) {
            int tmp = TestMain.i;
            tmp = tmp + 1;
            TestMain.i = tmp;
        }
    }

    public void run() {
        //每个线程会增加50次
        for(int i=0;i<50;i++){
            add();
        }
    }
}

public class TestMain {

    static int i=0;
    static Object o = new Object();

    public static void main(String[] args) throws InterruptedException {


//        创建100个线程
        for(int i=0;i<100;i++){
            Thread t =  new Thread(new Task());
            t.start();
        }

        Thread.sleep(1000);
        System.out.println(i);

    }
}

这次add还是普通方法,而add的函数体 都包含在 synchronized中,
这样写的时候, synchronized后面有个括号, 其中需要一个对象,也就是锁, 这样的好处是 这个锁可以根据需要, 传不同的对象,前面两种方式 一个是 所在实例的作为锁,一个是所在类作为锁,有些不灵活, 第三种方法,你可以将任何对象传进来,这其实是为了 缩小锁定的范围。

毕竟锁定和多线程是矛盾的。一定要选择合适的 同步范围 。
正确性是第一优先的, 如果程序无法保证正确,那就无法使用,
在保证正确性的前提下, 缩小锁定的范围, 提高程序的整体效率,是追求的目标。

相关文章

网友评论

    本文标题:synchronized 关键字 用法

    本文链接:https://www.haomeiwen.com/subject/cjcutxtx.html