多线程的同步

一 、多线程同步的背景

  • 多线程环境中，可能会有两个或更多个的线程试图同时访问一个有限的资源。必须对这种潜在的资源冲突进行预防。
  • 解决办法：在线程使用一个资源时为其加锁即可。访问资源的第一个线程为其加上锁以后，其他线程不能再使用那个资源，除非被解锁。

二、多线程同步的实现

1、对于访问某个关键共享资源的所有方法，都必须把他们设为synchronized。例如：

public synchronized void f() {...}
public synchronized void g() {...}

2、synchronized 关键字
当用synchronized关键字秀是一个方法时，该方法叫做同步方法

3、Java中的每个对象都有一个锁（lock）或者叫做监听器（monitor）。当访问某个对象的synchronized方法时，就会将该对象上锁，此时其它任何线程都无法再去访问该synchronized方法了，直到之前的那个线程执行方法完毕后或是抛出异常，该对象的锁才会被解开，其它线程才有可能去访问synchronized方法。FetchMoney例子说明：

/**
 * 如果想保护某些资源不被多个线程同时访问，可以强制通过synchronized方法访问那些资源。 
 * 调用synchronized方法时，对象就会被锁定。
 * @author Chuan
 *
 */
public class FetchMoney
{
    public static void main(String[] args)
    {
        Bank bank = new Bank();
        MoneyThread t1 = new MoneyThread(bank);
        MoneyThread t2 = new MoneyThread(bank);
        t1.start();
        t2.start();
    }
}

class  Bank
{
    private int money = 1000;
    
    public synchronized int getMoney(int number)
    {
        if (number < 0)
        {
            return -1;
        }
        else if (number > money)
        {
            return -2;
        }
        else if (money < 0)
        {
            return -3;
        }
        try
        {
            Thread.sleep(1000);
        }
        catch (InterruptedException e)
        {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
        money -= number;
        System.out.println("left money:" + money);
        return number;      
    }
}
class MoneyThread extends Thread
{
    private Bank bank;
    public MoneyThread(Bank bank)
    {
        this.bank = bank;
    }
    
    @Override
    public void run()
    {
        System.out.println(bank.getMoney(800));
    }
}

程序运行结果如下：


image.png

4、如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。ThreadTest4例子说明：

/**
 * 如果一个对象有多个synchronized方法，某一时刻某个线程已经进入到了某个synchronized方法，
 * 那么在该方法没有执行完毕前，其他线程是无法访问该对象的任何synchronized方法的。
 * @author Chuan
 *
 */
public class ThreadTest4
{
    public static void main(String[] args)
    {
        Example example = new Example();

        ThreadFirst t1 = new ThreadFirst(example);
        ThreadSecond t2 = new ThreadSecond(example);

        t1.start();
        t2.start();
    }
}

class Example
{
    public synchronized void execute()
    {
        for (int i = 0; i < 10; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("hello " + i);
        }
    }
    
    public synchronized void execute2()
    {
        for (int i = 0; i < 10; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("world " + i);
        }
    }
}

class ThreadFirst extends Thread
{
    private Example example;
    public ThreadFirst(Example example)
    {
        this.example = example;
    }
    @Override
    public void run()
    {
        example.execute();
    }
}

class ThreadSecond extends Thread
{
    private Example example;
    public ThreadSecond(Example example)
    {
        this.example = example;
    }
    @Override
    public void run()
    {
        example.execute2();
    }
}

程序运行结果如下：


image.png

5、如果synchronized方法是static的,那么当线程访问该方法时，它锁的并不是synchronized所在的对象，而好似synchronized方法所在对象所对应的Class对象。因为Java中无论一个类有多少个对象，这些对象都会对应唯一一个Class对象，因此当线程分别访问一个类的两个对象的static、synchronized方法时，它们的执行顺序也是顺序的，也就是一个线程先去执行方法，执行完毕后另一个线程才开始执行。ThreadTest5例子说明：

/**
 * 如果某个synchronized方法是static的，那么当线程访问该方法时，
 * 它锁的并不是synchronized方法所在的对象，而是synchronized方法所在的对象所对应的Class对象，
 * 因为Java中无论一个类有多少个对象，这些对象会对应唯一一个Class对象，
 * 因此当线程分别访问同一个类的两个对象的两个static，synchronized方法时，
 * 他们的执行顺序也是顺序的，也就是说一个线程先去执行方法，执行完毕后另一个线程才开始执行。
 * @author Chuan
 *
 */
public class ThreadTest5
{
    public static void main(String[] args)
    {
        Example2 example = new Example2();
        ThreadFirst2 t1 = new ThreadFirst2(example);

        example = new Example2();
        ThreadSecond2 t2 = new ThreadSecond2(example);

        t1.start();
        t2.start();
    }
}

class Example2
{
    public synchronized static void execute()
    {
        for (int i = 0; i < 10; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("hello " + i);
        }
    }
    
    public synchronized static void execute2()
    {
        for (int i = 0; i < 10; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            System.out.println("world " + i);
        }
    }
}

class ThreadFirst2 extends Thread
{
    private Example2 example;
    public ThreadFirst2(Example2 example)
    {
        this.example = example;
    }
    @Override
    public void run()
    {
        this.example.execute();
    }
}

class ThreadSecond2 extends Thread
{
    private Example2 example;
    public ThreadSecond2(Example2 example)
    {
        this.example = example;
    }
    @Override
    public void run()
    {
        this.example.execute2();
    }
}

程序运行结果如下：


image.png

6、synchronized块，写法;

private Object object = new Object();
synchronized(object)
{
    ...
}

表示线程在执行的时候会对object对象上锁。ThreadTest6例子shuoming

public class ThreadTest6
{
    public static void main(String[] args)
    {
        Example3 example = new Example3();

        ThreadFirst3 t1 = new ThreadFirst3(example);
        ThreadSecond3 t2 = new ThreadSecond3(example);

        t1.start();
        t2.start();
    }
}

class Example3
{
    private  Object object = new Object();
    
    
    public   void execute()
    {
        synchronized(object)
        {
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    Thread.sleep((long)(Math.random() * 1000));
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                System.out.println("hello " + i);
            }
        }
    }
    
    public   void execute2()
    {
        synchronized(object)
        {
            for (int i = 0; i < 10; i++)
            {
                try
                {
                    Thread.sleep((long)(Math.random() * 1000));
                }
                catch (InterruptedException e)
                {
                    e.printStackTrace();
                }
                System.out.println("world " + i);
            }
        }
        
    }
}

class ThreadFirst3 extends Thread
{
    private Example3 example;
    public ThreadFirst3(Example3 example)
    {
        this.example = example;
    }
    @Override
    public void run()
    {
        example.execute();
    }
}

class ThreadSecond3 extends Thread
{
    private Example3 example;
    public ThreadSecond3(Example3 example)
    {
        this.example = example;
    }
    @Override
    public void run()
    {
        example.execute2();
    }
}

程序硬性结果如下：


image.png

7、synchronized方法是一种粗粒度的并发控制，某一时刻只能有一个线程执行该synchronized方法；synchronized块是一种细粒度的并发控制，只会将块中的代码同步，位于方法内，synchronized块之外的代码是可以被多个线程同时访问的。

8、同步的线程状态图


image.png

9 、线程的相互作用

  • 线程的相互作用主要涉及到两个方法：wait()和notify()，这两个方法是定义在Object类中的，而且是final的。因此会被所有的Java类继承但是无法重写。这两个方法要求在调用时线程已经获得了对象的锁，因此对这两个方法的调用需要放在synchronized方法或块中。当线程执行了wait方法时，它会释放掉对象的锁。
  • 线程的相互作用主要涉及到两个pool：wait poll 和lock pool。

  • 具有wait()和notify()的线程状态图：


    image.png
  • 看一个同步的综合例题：Sample类里有一个整型变量number（初始值为0），两个方法increase() 加1和decrease()减1。另外有一个线程IncreaseThread调用加1方法，还有一个线程DecreaseThread调用减1方法。最终结果是实现0 1 0 1 0 1...的变更。
    （1）首先实现Sample类。
    其中increase()和decrease方法都是suynchronized修饰的，即同步方法。每个方法中都调用了wait()和notify()方法，以实现不同线程间的相互作用。需要注意的是，wait()方法会释放锁，并让线程在此位置停止执行，直到该线程获得锁以及系统资源，就会继续从此为止向下执行。因此紧跟wait()方法后仍需要判断条件是否满足。这也是下面程序中采用while循环判断，而不用if判断的原因。
public class Sample
{
    private int number;
    
    public synchronized void increase()
    {
        //每次做事情前都要判断条件是否满足
        while (number != 0)
        {
            try
            {
                //wait会释放锁，并且停在此处.当获得通知后，继续向下执行
                //此处需要在等待结束后继续判断是否满足条件，因为其他线程可能在等待期间已经进行了操作
                wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        
        number++;
        System.out.println(number);
        notify();
    }
    
    public synchronized void decrease()
    {
        //每次做事情前都要判断条件是否满足
        while (number == 0)
        {
            try
            {
                wait();
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println(number);
        notify();
    }
}

（2）调用加1方法的IncreaseThread线程

public class IncreaseThread extends Thread
{
    private Sample sample;
    
    public IncreaseThread(Sample sample)
    {
        this.sample = sample;
    }
    
    @Override
    public void run()
    {
        for(int i = 0; i < 10; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            this.sample.increase();
        }
    }
}

(3)调用减1方法的DecreaseThread线程

public class DecreaseThread extends Thread
{
    private Sample sample;
    
    public DecreaseThread(Sample sample)
    {
        this.sample = sample;
    }
    
    @Override
    public void run()
    {
        for(int i = 0; i < 10; i++)
        {
            try
            {
                Thread.sleep((long)(Math.random() * 1000));
            }
            catch (InterruptedException e)
            {
                e.printStackTrace();
            }
            this.sample.decrease();
        }
    }
}

(4)MainTest主程序进行测试

public class MainTest
{
    public static void main(String[] args)
    {
        Sample sample = new Sample();
        
        IncreaseThread t1 = new IncreaseThread(sample);
        DecreaseThread t2 = new DecreaseThread(sample);
        
        IncreaseThread t3 = new IncreaseThread(sample);
        DecreaseThread t4 = new DecreaseThread(sample);
        
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

（6）MainTest的运行结果


image.png

10、另一个会导致线程暂停的方法就是Thread类的sleep方法，它会导致线程暂停指定的毫秒数，但线程在睡眠的过程中不会释放掉对象的锁。

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

推荐阅读更多精彩内容

  • Java多线程学习
    Java多线程学习 [-] 一扩展javalangThread类 二实现javalangRunnable接口 三T...
    影驰阅读 2,949评论 1赞 18
  • Java基础——有点闹的线程和进程
    一、进程和线程 进程 进程就是一个执行中的程序实例，每个进程都有自己独立的一块内存空间，一个进程中可以有多个线程。...
    阿敏其人阅读 2,607评论 0赞 13
  • Java多线程学习（吐血超详细总结）
    该文章转自：http://blog.csdn.net/evankaka/article/details/44153...
    加来依蓝阅读 7,333评论 3赞 87
  • java多线程
    本文主要讲了java中多线程的使用方法、线程同步、线程数据传递、线程状态及相应的一些线程函数用法、概述等。 首先讲...
    李欣阳阅读 2,438评论 1赞 15
  • 七分少年味
    阿七的整个七月都是灰色的，直到在看见全校的大学录取结果时，阿七所有关于自己志愿撞车的难过都消失的干干净净了，因为她...
    3dafd90caf21阅读 206评论 0赞 1