synchronized使用

synchronized是一种同步锁。他修饰的对象有一下几种：

  • 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号括起来的代码，作用的对象是调用这个代码块的对象。
  • 修饰一个方法，被修饰的方法称为同步语句块，其作用的范围是整个方法，作用的对象是调用这个方法的对象。
  • 修饰一个静态的方法，其作用是整个静态方法，作用的对象是这个类的所有对象。
  • 修饰一个类，其作用的范围是synchronized后面括号括起来的部分，主作用的对象是这个类的所有对象。

修饰一个代码块

  • 一个线程访问一个对象中的同步代码块时：
class SyncThread impltements Runnable{
    private static final count;
    public SyncThread(){
        count = 0;    
    }
    public void run(){
        synchronized(this){
            for(int i = 0;i<5;i++){
               try{
                System.out.println(Thread.currentThead().getName()+":"+(count++))
                Thread.sleep(100);
               }catch(....){
                .......
               } 
            }    
        }
    }
    public int getCount(){
        return count;
    }
    SyncThread syncThread = new SyncThread();
    Thread thread1 = new Thread(syncThread, "11");
    Thread thread2 = new Thread(syncThread, "22");
    thread1.start();
    thread2.start();
}

运行结果：
11：0
11：1
11：2
11：3
11：4
22：5
22：6
22：7
22：8
22：9

当两个并发线程同时访问同一个对象中的同步代码块时，在同一时刻只能有一个线程得到执行，另一个线程受到阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。
但是当我们把运行代码改一下：

Thread thread1 = new Thread(new SyncThread(),"11");
Thread thread2 = new Thread(new SyncThread(), "22");
thread1.start();
thread2.start();

运行结果：
11：0
22：1
11：2
22：3
11：4
22：5
22：6
11：7
11：8
22：9

因为以上代码中synchronized锁定的是对象，这时会有两把锁分别锁定对象1和对象2，而这两把锁时互不干扰的，不形成互斥，所以两个线程可以同时执行。
2.当一个线程访问对象的一个同步代码块时，另一个线程仍然可以同时访问该对象中的非synchronized同步代码块。3.指定要给某个对象加锁

class Account{
    String name;
    int amount;
    
    public Account(String name, int amount){
        this.name = name;
        this.amount = amount;
    }
    
    //存钱
    public void deposit(int amt){
        amount += amt;
        try{
            Thread.sleep(100);
        }catch(...){
            ....
        }
    }
    
    //取钱
    public void withdraw(int amt){
        amount -= amt;
        try{
            Thread.sleep(100);
        }catch(...){
            ...
        }
    }
    
    public int getAmount(){
        return amount;
    }
}

class AccountOperator implements Runnable{
    
    private Account account;
    
    public void run(){
        synchronized(account){
            account.deposit(500);
            account.withdraw(500);
            System.out.println(Thread.currentThread().getName() + ":" + account.getAmount());
        }
    }
}

//调用代码
Account account = new Account("zhangsan", 10000);
AccountOperator accountOperator = new AccountOperator(account);
final int THREAD_NUM = 5;
Thread[] threads = new Thread[THREAD_NUM];
for(int i = 0;i<THREAD_NUM;i++){
    thread[i] = new Thread(accountOperator, "thread"+i);
    thread[i].start();
}

运行结果：
Thread3:10000
Thread2:10000
Thread1:10000
Thread4:10000
Thread0:10000

在AccountOperator类的run方法中，我们用synchronized给account对象加了锁。这时，当一个线程访问account对象时，其他试图访问account对象的线程将会阻塞，知道该线程访问account对象结束。
当一个有明确的对象作为�锁时，就可以用类似下面：

public void method3(SomeObject obj){
    //obj锁定的对象
    synchronized(obj){
        //todo
    }
}

当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁：

class Test implements Runnable{
    
    private byte[] lock = new byte[0];
    
    public void method(){
        synchronized(lock){
            //todo
        }
    }
    
    public void run(){
    }
}

说明：零长度的byte数组对象创建起来比任何对象都经济：生成零长度的byte[]对象只需3条操作码，而Object lock = new Object()则需要7行操作码。
修饰一个方法

public synchronized void run(){

    for(int i = 0;i<5;i++){
        try{
            System.out.println(Thread.currentThread().getName() + ":" + (count++));
         Thread.sleep(100);
        }catch(...){
            ...
        }
    }
    
}

synchronized作用于整个方法的写法：

public synchronized void method(){
    //todo
}

或者
public void method(){

    synchronized(this){
        //todo
    }
    
}

在用synchronized修饰方法时要注意一下几点：

1.synchronized关键字不能继承。
2.在定义接口方法时不能使用synchronized关键字
3.构造方法不能使用synchronized关键字，但可以使用sync hronized代码块来进行同步。
修饰一个静态方法

public synchronized static void method(){
    //todo
}

我们知道静态方法属于类而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。

class SyncThread implements Runnable{

    private static int count;
    
    public SyncThread(){
        count = 0;
    }
    
    public synchronized void run(){
    }
    
    public synchronized static void method(){
        for(int i = 0;i<5;i++){
            try{
                Log.e(TAG, "method: "+Thread.currentThread().getName()+":"+(count++));
                Thread.sleep(100);
            }catch(...){
                ...
            }
        }
    }
}

调用代码：
SyncThread syncThread1 = new SyncThread();
SyncThread syncThread2 = new SyncThread();
Thread thread1 = new Thread(sychThread1, "SyncThread1");
Thread thread2 = new Thread(sychThread2, "SyncThread2")；
thread1.start();
thread2.start();

运行结果：
SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9

syncThread1和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行却保持了线程同步，因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于同一把锁。
修饰一个类

class ClassName{

    public void method(){
        synchronized(ClassName.class){
            //todo
        }
    }
    
}

class SyncThread implements Runnable{

    private static int count;
    
    public SyncThread(){
        count = 0;
    }
    
    public void run(){
        method();
    }
    
    public static void method(){
        synchronized(SyncThread.class){
            for(int i = 0; i<5;i++){
                try{
                    log.e(TAG, "run: "+Thread.currentThread().getName()+":"+count++);
                    Thread.sleep(100);
                }catch(...){
                    ...
                }
            }
        }
    }
}

运行结果：
SyncThread1:0
SyncThread1:1
SyncThread1:2
SyncThread1:3
SyncThread1:4
SyncThread2:5
SyncThread2:6
SyncThread2:7
SyncThread2:8
SyncThread2:9

总结：1.无论synchronized关键字加在方法还是对象上，如果他作用的对象是非静态的，则它取得的锁是对象，如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是类，该类所有的对象同一把锁。
2.每个对象只有一个锁（lock）与之关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
3.实现同步时要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。

©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 230,563评论 6赞 544
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 99,694评论 3赞 429
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 178,672评论 0赞 383
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 63,965评论 1赞 318
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 72,690评论 6赞 413
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 56,019评论 1赞 329
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 44,013评论 3赞 449
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 43,188评论 0赞 290
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 49,718评论 1赞 336
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 41,438评论 3赞 360
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 43,667评论 1赞 374
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 39,149评论 5赞 365
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 44,845评论 3赞 351
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 35,252评论 0赞 28
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 36,590评论 1赞 295
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 52,384评论 3赞 400
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 48,635评论 2赞 380