线程同步问题

线程之间的关系

1. 线程间同步：相互竞争 相互排斥
2. 线程间协作：线程间相互协作

线程同步

问题引出

一个多线程的程序如果是通过Runnable接口实现的，则意味着类中的属性将被多个线程共享，由此引出资源的同步问题，即当多个线程要操作同一资源时，有可能出现错误。

练习： 分别使用两种编程方法实现买票的程序
1. 继承Thread方法

public class TestTicketThread{    public static void main(String[] a){        TicketThread tThread1 = new TicketThread();        TicketThread tThread2 = new TicketThread();        TicketThread tThread3 = new TicketThread();        tThread1.start();        tThread2.start();        tThread3.start();    }}class TicketThread extends Thread {    private int ticket = 5;    public void run(){        for (int i = 0; i < 5; i++){            if (ticket > 0){                System.out.println(this.getName() + "卖票：ticket = " + ticket--);            }        }    }}

运行结果：每个线程单独买票

1. 实现Runnable接口

package zhi;/** * Created by admin on 2017/5/17. */public class TestTicketRunnable{    public static void main(String[] a){        TicketRunnable Thread = new TicketRunnable();        new Thread(Thread).start();        new Thread(Thread).start();        new Thread(Thread).start();    }}class TicketRunnable implements Runnable {    private int ticket = 5;    @Override    public void run() {        for (int i = 0; i < 5; i++){            if (ticket > 0){                System.out.println(Thread.currentThread().getName() + "卖票：ticket = " + ticket--);            }        }    }}

运行结果：
Thread-0卖票：ticket = 5
Thread-0卖票：ticket = 2
Thread-2卖票：ticket = 3
Thread-1卖票：ticket = 4
Thread-0卖票：ticket = 1

1. 结果分析
   第二种方法，虽然启动了3个线程，但是3个线程一共卖了5张票，即ticket属性被所有的线程对象共享。而第一种方法，3个线程各卖了5张票，没有实现属性的共享。

结论：实现Runnable接口的方法相对于继承Thread类来说，适合多个相同程序代码的线程去处理统一资源的情况。

练习： 在上述卖票事例的基础上，做如下修改

public class TestTicketRunnable{    public static void main(String[] a){        TicketThread tThread = new TicketThread();        new Thread(tThread).start();        new Thread(tThread).start();        new Thread(tThread).start();    }}class TicketThread implements Runnable {    private int ticket = 5;    public void run(){        for (int i = 0; i < 5; i++){            if (ticket > 0){                try {                    Thread.sleep(300);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName() + "卖票：ticket = " + ticket--);            }        }    }}

运行结果：
Thread-0卖票：ticket = 5
Thread-2卖票：ticket = 5
Thread-1卖票：ticket = 4
Thread-1卖票：ticket = 2
Thread-2卖票：ticket = 3
Thread-0卖票：ticket = 3
Thread-0卖票：ticket = -1
Thread-1卖票：ticket = 1
Thread-2卖票：ticket = 0

分析：卖票的业务步骤如下：
1. 判断票数是否大于0，大于0则表示还有票可以卖；
2. 如果票数大于0，则将票卖出。

在上面的代码中，在步骤(1)和(2)之间加入了延迟操作，那么一个线程就有可能在判断完之后，还没有对票数进行减操作之前，其他线程就已经将票数减少了，这样一来就会出现票数为负的情况。

要解决这个问题，必须使用同步。同步是指多个操作在同一个时间段内只能有一个线程进行，其他线程要等待此线程完成之后才可以继续执行。

使用synchronized同步代码块——隐式加锁

为避免竞争状态，应该防止多个线程同时进入程序的某一个特定的部分，程序中的这部分称为临界区。
第一种方法可以在代码块上加上synchronized关键字，则此代码块就称为同步代码块。
同步代码块同一时刻只能有一个线程访问

练习： 修改上面的代码，用同步机制解决资源共享问题

public class TestTicketRunnable{    public static void main(String[] a){        TicketThread tThread = new TicketThread();        new Thread(tThread).start();        new Thread(tThread).start();        new Thread(tThread).start();    }}class TicketThread implements Runnable {    private int ticket = 5;    public void run(){        for (int i = 0; i < 5; i++){            synchronized(this){                    if (ticket > 0){                        try {                            Thread.sleep(300);                        } catch (InterruptedException e) {                            e.printStackTrace();                        }                        System.out.println(Thread.currentThread().getName() + "卖票：ticket = " + ticket--);                    }            }        }    }}

运行结果：

Thread-0卖票：ticket = 5
Thread-0卖票：ticket = 4
Thread-2卖票：ticket = 3
Thread-2卖票：ticket = 2
Thread-2卖票：ticket = 1

分析：使用同步代码块之后，没有出现重复票和票为负数的情况。

在方法前加入synchronized关键字，则该方法为同步方法。

public class TestSynchronizedMethod {    public static void main(String[] a){        TicketThreadMethod tThread = new TicketThreadMethod();        new Thread(tThread).start();        new Thread(tThread).start();        new Thread(tThread).start();    }}class TicketThreadMethod implements Runnable {    private int ticket = 5;    public void run(){        for (int i = 0; i < 5; i++){            this.sale();        }    }    public synchronized void sale(){            if (ticket > 0){                try {                    Thread.sleep(300);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName() + "卖票：ticket = " + ticket--);            }    }}

利用加锁同步——显式加锁lock.lock()

线程协作在研究