MENU

线程同步

June 30, 2018 • Read: 181 • Java

对访问同一个资源的多个线程进行协调的过程,就叫线程同步

用一个简单的例子讲述线程同步问题:

小明账户里有3000元钱,他拿存折去银行取2000,银行的机器首先判断账户里的钱够不够2000,判断够。与此同时,小明的老婆拿着小明的银行卡去了另一家银行取钱,也取2000,判断也够,小明的老婆取出来了,账户里的钱变为了1000,这时小明这边的机器已经判断过足够了,所以小明也取出了2000,账户的钱变为1000。最终的结果就是,小明和他老婆分别取了2000块钱,账户还剩1000。

解决这个问题的方法也很简单,只要规定,访问统一账户的人同时只能有一个。就比方说,两台电脑不能同时登陆同一个qq

下面先看一个示例

public class TestSync implements Runnable{
    Timer timer = new Timer();
    public static void main(String[] args) {
        TestSync test = new TestSync();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
    public void run() {
        timer.add(Thread.currentThread().getName());
    }
}
class Timer{
    private static int num = 0;
    public void add(String name) {
        num++;
        try {
            Thread.sleep(1);
        }catch(InterruptedException e) {}
        System.out.println(name + ",你是第" + num + "个使用timer的线程");
    }
}

首先用一个内存图分析一下整个程序:

image

输出结果为:

t1,你是第2个使用timer的线程
t2,你是第2个使用timer的线程

分析一下这个程序的执行:

首先一个线程在执行add方法的过程中,执行了一次num++,此时num的值是1,然后当前线程sleep,另一个线程开始执行add方法,又执行了一次num++,此时num的值是2,然后这个线程sleep。上一个线程sleep结束了,输出,num的值就是2,然后另一个线程sleep也结束了,输出,num的值也是2

其实这就跟前面的取钱例子一样,解决办法就是给add方法加一把锁,让他同时只能有一个线程访问,不论当前线程是否睡眠,只有当访问add方法的线程结束了,才能允许另一个线程访问

public class TestSync implements Runnable{
    Timer timer = new Timer();
    public static void main(String[] args) {
        TestSync test = new TestSync();
        Thread t1 = new Thread(test);
        Thread t2 = new Thread(test);
        t1.setName("t1");
        t2.setName("t2");
        t1.start();
        t2.start();
    }
    public void run() {
        timer.add(Thread.currentThread().getName());
    }
}
class Timer{
    private static int num = 0;
    public void add(String name) {
        synchronized (this) {
            num++;
            try {
                Thread.sleep(1);
            }catch(InterruptedException e) {}
            System.out.println(name + ",你是第" + num + "个使用timer的线程");
        }
    }
}

另一种写法,直接给方法加锁

public class TestDeadLock implements Runnable{
    public int flag = 1;
    static Object o1 = new Object(),o2 = new Object();
    public void run() {
        System.out.println("flag = " + flag);
        if(flag == 1) {
            synchronized(o1) {
                try {
                    Thread.sleep(500);
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
                synchronized(o2) {
                    System.out.println("1");
                }
            }
        }
        if(flag == 0) {
            synchronized(o2) {
                try {
                    Thread.sleep(500);
                }catch(Exception e) {
                    e.printStackTrace();
                }
                synchronized(o1) {
                    System.out.println("2");
                }
            }
        }
    }
    public static void main(String[] args) {
        TestDeadLock td1 = new TestDeadLock();
        TestDeadLock td2 = new TestDeadLock();
        td1.flag = 1;
        td2.flag = 0;
        Thread t1 = new Thread(td1);
        Thread t2 = new Thread(td2);
        t1.start();
        t2.start();
    }
}

运行结果如下图:

image

首先分别给两个线程内的flag变量分别赋值为1和0,那么他们就会分别执行对应的if语句。对于flag = 1来说,它先锁住o1,让它sleep500毫秒,只要再锁住o2,就可以打印1了;对于flag = 0来说,它先锁住o2,让它sleep500毫秒,只要再锁住o1,就可以打印2了,所以他们分别锁住一个线程对象,等待另一个线程对象,但是他们永远不可能锁住另一个线程对象了,所以程序进入了死锁

一道面试题

public class TT implements Runnable{
    static int b = 100;
    public synchronized static void m1() throws InterruptedException {
        b = 1000;
        Thread.sleep(5000);
        System.out.println("b = " + b);
    }
    public static void m2() {
        b = 2000;
        System.out.println(b);
    }
    public void run() {
        try {
            m1();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();
        Thread.sleep(1000);
        tt.m2();
    }
}

上述程序输出结果是什么?

正确答案:

2000
b = 2000

面试题变形

public class TT implements Runnable{
    static int b = 100;
    public synchronized static void m1() throws InterruptedException {
        b = 1000;
        Thread.sleep(5000);
        System.out.println("b = " + b);
    }
    public synchronized static void m2() throws InterruptedException {
        Thread.sleep(2500);
        b = 2000;
    }
    public void run() {
        try {
            m1();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        TT tt = new TT();
        Thread t = new Thread(tt);
        t.start();
        tt.m2();
    }
}

最后结果是:b = 1000

用一段文字解释一下上面两个问题,首先是第一个程序,m1方法带锁,m2不带锁,主线程中创建线程t,t调用m1方法,将b的值改为1000,然后sleep,此时主线程也在继续执行,调用了m2方法,将b的值改为2000,打印b。随后m1继续执行,打印的b当然就是2000

对于第二个程序,m1和m2两个方法都带锁,那么这两个方法就不能被同时访问,同时只能有一个方法在执行,另一个方法会等待。首先t开始,然后主线程继续执行m2,此时m1是不能会被执行的,因为两个方法都带锁,m2执行完,b的值被改为2000,然后执行m1,b的值又被改为1000

最后编辑于: October 19, 2018
Archives Tip
QR Code for this page
Tipping QR Code
Leave a Comment