频道栏目
首页 > 程序开发 > 软件开发 > Java > 正文
java多线程(三) 线程的同步与通信
2017-02-13 09:22:50      个评论    来源:带你装逼带你飞的专栏  
收藏   我要投稿

java多线程(三) 线程的同步与通信:线程的同步是指协同、协助、互相配合,指多个线程协同配合访问临界资源。

为什么要进行线程的同步?
主要是线程可见性问题
java 中如何实现线程同步?
一般说来java线程实现同步有以下几种方式

1通过synchronized实现同步
这里主要有两种方式,分别是同步块,与同步方法:
同步块:

    public void saveMoney2(int money){
        synchronized (this){
            account += money;
        }
    }

其中这里的this指的是当前调用该方法的对象,这样锁就是当前对象的锁,也可以换成其他的对象,这样就表示锁是其他对象的锁。

同步方法:

public synchronized void saveMoney(int money){
        account += money;
        System.out.println(Thread.currentThread().getName()+" 余额:<<----- " + getAccount());
}

同步方法中锁表示当前对象的锁,即调用该方法的锁。

下面看一个完整的线程同步的例子

public class Bank {
    private int account;

    public int getAccount() {
        return account;
    }

//    public  void saveMoney(int money){
//        account += money;
//    }

    public synchronized void saveMoney(int money){
        account += money;
    }

    public void saveMoney2(int money){
        synchronized (this){
            account += money;
        }
    }

//    public void getMoney(int money){
//        account -= money;
//    }

    public synchronized void getMoney(int money){
        account -= money;
    }






public class SaveTask implements Runnable {
    private Bank bank;

    public SaveTask(Bank bank){
        this.bank = bank;
    }

    @Override
    public void run() {
        while (true){
            bank.saveMoney(20);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

}


/**
 * Created by qiyei2015 on 2017/2/11.
 */
public class TakeTask implements Runnable {

    private Bank bank;

    public TakeTask(Bank bank){
        this.bank = bank;
    }

    @Override
    public void run() {
        while (true){
            bank.getMoney(30);
            try {
                Thread.sleep(300);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试代码:
private static void testSynchronzied(){
        Bank bank = new Bank();
        SaveTask saveTask = new SaveTask(bank);
        TakeTask takeTask = new TakeTask(bank);

        for (int i = 0 ;i < 10;i++){
            new Thread(saveTask,"存钱 线程" + (i+1)).start();
            new Thread(takeTask,"取钱 线程"+ (i+1)).start();

        }

    }

程序输出:

2 线程通信

这里的通信主要是指线程的唤醒,比如一个线程进入阻塞状态,另一个线程去唤醒它。用到的主要是wait()与notify()。notifyAll()

wait():Object类中方法,线程中调用了wait()方法,线程会进入阻塞等待状态,并释放同步锁,线程会进入等待池。因此需要在同步块或者同步方法中调用
notify():Object类中方法,唤醒同一锁中等待池中的一个线程,唤醒的具体线程由虚拟机实现
notifyAll();Object类中方法,唤醒同一锁中等待池中的所有方法。

接着上面的例子,我们发现我们的余额会变成负数,这个与实际情况肯定是不相符的。因此我们需要修改我们的程序,让余额不能为负数,这里就会用到我们的线程通信的知识了。

修改取钱代码,只有取了之后的余额大于200。才能取钱,否则让取钱线程在此处等待。

    public synchronized void getMoney(int money){
        //如果小于200,则等待存钱线程
        if ((account - money) < 200){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }else {
            account -= money;
            System.out.println(Thread.currentThread().getName()+" 余额:------>> " + getAccount());
        }
    }

修改存钱线程,当发现余额大于200时,就表明可以取钱了。这样我们就能保持我们的余额永远大于200。

    public synchronized void saveMoney(int money){
        account += money;
        //存钱结束后唤醒全部存钱线程
        if (account > 200){
            notifyAll();
        }
        System.out.println(Thread.currentThread().getName()+" 余额:<<----- " + getAccount());
    }

其他的都不变,运行代码,程序输出:

可以发现,余额不再会低于200了,表明达到我们的效果了。

3 线程join()

关于线程的join的理解是一个难点,我们还是看JDK的解释。
public final void join()
throws InterruptedException
Waits for this thread to die.
关于这里的this就是指调用join()的线程对象。因为join()是一个实例方法。意思是等待调用join()线程对象结束。例如:t.join()用于阻塞调用join()方法的线程,直到t运行结束。

注意:一般t.join()用于在主线程调用。用于按照一定的顺序组织多个线程的运行
例子:假设有1,2,3,4四个线程,我现在想让他们按照3,1,2,4顺序运行,则可以使用join来实现。

/**
 * Created by qiyei2015 on 2017/2/6.
 */
public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        int i = 0;
        while (i < 5){
            i++;
            String name = Thread.currentThread().getName();
            System.out.println(name + " 运行....." + i);
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

测试代码:
    private static void testJoin(){
        MyThread thread1 = new MyThread("线程1");
        MyThread thread2 = new MyThread("线程2");
        MyThread thread3 = new MyThread("线程3");
        MyThread thread4 = new MyThread("线程4");

        try {
            thread3.start();
            thread3.join();

            thread1.start();
            thread1.join();

            thread2.start();
            thread2.join();

            thread4.start();
            thread4.join();

            System.out.println("线程全部运行结束");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

运行结果如下:

好,关于本节内容就完成了,下一节会讲JVM内存模型与线程可见性问题

点击复制链接 与好友分享!回本站首页
上一篇:java匿名内部类
下一篇:Java按值传递还是按引用传递详细解说
相关文章
图文推荐

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训

版权所有: 红黑联盟--致力于做实用的IT技术学习网站