Java多线程通信、同步卖票实例--线程安全、详细注释

实现线程的有继承 thread类和实现runnable接口两种方式，一般没人会说实现callable接口这个方式，所以，这就暂不考虑这个方法。

下面分别以这2种方式实现线程安全的卖票的例子。

1，继承thread类来实现多线程卖票。

先是票的代码

package com.lxk.threadTest.ticket.extend;/** * Created by lxk on 2017/6/25 */public class Ticket extends Thread {    //private int ticket = 100;//创建一个对象就有100张票。错误一：几个线程都打印一次100-1。不合适。所以，如下操作，换成静态变量。    private static int ticket = 100;//静态变量是所有对象都共享，100张票。几个线程，卖的都是一个票。但是，一般都不这么干，静态变量，生命周期太长。    /**     * 实现自定义线程的名称     */    public Ticket(String name) {        super(name);    }    /**     * 这地方就是需要注意的地方，如果不加[synchronized]，就会发生线程安全问题。     * 奇怪了，     * 怎么还是线程不安全，还是会执行出0，-1，-2。的结果出来。     * 错误原因的分析：     * 可以看到添加的锁的对象是this，但是在main方法中有4个对象，每个对象都对自己加锁，锁不同，所以，还是不安全的。     * 比如：换成都对Ticket.class（内存中就有一份字节码文件存在）加锁，那就安全啦。     */    @Override    //public synchronized void run() {//【①】 错误二：即使添加了同步方法(此处注释的代码)，锁的是this，是线程不安全的。    public void run() {        while (true) {            //synchronized (this) {//【①】 错误二：即使添加了同步代码块，锁的也是this，是线程不安全的。            //synchronized (Ticket.class) {//【①】正确同步方式： 必须所有实例化的对象都锁相同的一个家伙，那就安全啦。                if (ticket > 0) {                    //睡一下，好实现线程不安全的现象,前提是这个方法，没有添加synchronized，同步函数。                    try {                        Thread.sleep(10);                    } catch (Exception ignored) {                    }                    //错误三：不添加同步(即注释掉标记:①的所有代码)，多线程操作则会打印出0，-1，-2                    //分析：                    //假设1线程运行到下行代码处，还未执行，此时ticket的值仍然为1，那么其他线程继续执行还是都会进到这个判断                    //假设其他几个线程都恰好停到此处，那么依次执行完之后，四个线程的结果就是，1，0，-1，-2.                    System.out.println(this.getName() + " sale：" + ticket--);                }            //} //【①】        }    }}

下面是main方法

package com.lxk.threadTest.ticket.extend;/** * 卖票例子（继承Thread类，实现多线程） * <p> * Created by lxk on 2017/6/25 */public class Main {    public static void main(String[] args) {        Ticket ticket1 = new Ticket("ticket1");        Ticket ticket2 = new Ticket("ticket2");        Ticket ticket3 = new Ticket("ticket3");        Ticket ticket4 = new Ticket("ticket4");        ticket1.start();        ticket2.start();        ticket3.start();        ticket4.start();    }}

然后就是这个代码的执行结果。

先不要惊慌：我都说了线程安全了，怎么还是输出了0，-1，-2，这些个不合法的票呢。

其实，这是上面ticket类里面的代码把那些同步的代码都给注释了，就是要示范一下，怎么个线程不安全。

也就是带有这个的(//【①】)代码,打开的话(标记过的是错误的就表打开啦 )，就不会看到卖出0，-1，-2的票啦

上面几种情况，我都把详细的注释，写在代码里了。跟着代码走，应该可以很好的理解这个多线程是怎么运行的吧。

这有个前提：就是你知道cpu是轮询执行程序的。这个是最基本的概念啦，每个线程，他是说停就停的，知道这个就好说啦。

2，再是实现runnable接口来实现多线程卖票的实例。

还是先看票的代码

package com.lxk.threadTest.ticket.implement;/** * Created by lxk on 2017/6/25 */public class Ticket implements Runnable {    private int tick = 100;    boolean flag = true;    //Object object = new Object();    public void run() {        if (flag) {            while (true) {                //synchronized (object) {//这个同步代码块使用的锁是object，而下面的同步函数使用的是锁是this，所以，这么干就线程不安全。                synchronized (this) {//换成this就变得安全啦。说明下面同步函数使用的锁是this                    if (tick > 0) {                        try {                            Thread.sleep(10);                        } catch (Exception ignore) {                        }                        System.out.println(Thread.currentThread().getName() + "....sale...代码块 : " + tick--);                    }                }            }        } else {            while (true) {                show();            }        }    }    private synchronized void show() {//使用的锁就是this        if (tick > 0) {            try {                Thread.sleep(10);            } catch (Exception ignore) {            }            System.out.println(Thread.currentThread().getName() + "....sale...函数 : " + tick--);        }    }}

可以看到上面，因为第一个继承的例子中，使用了同步代码块，或者同步函数，来解决同步问题。那么在下面这个例子中，直接把2个给弄到一起，看效果。

线程1走同步代码块，线程2走同步方法。都可以实现多线程同步的效果。

然后就是看main的代码

package com.lxk.threadTest.ticket.implement;/** * 卖票例子（实现Runnable接口，实现多线程） * <p> * Created by lxk on 2017/6/25 */public class Main {    public static void main(String[] args) {        //test();        testStatic();    }    /**     * 测试普通的同步代码块和同步函数的同步效果。     * 结论：同步函数和同步代码块使用的锁都是this     */    private static void test() {        Ticket t = new Ticket();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        //现在修改为只有2个线程，1使用同步代码块，2使用同步函数。        //测试发现：两者使用的锁是不同的，因为使用的不是同一个锁，所以，线程还是不安全的。（下面分析为什么这要sleep()）        t1.start();        //这时候，在没有添加下面的sleep的时候，代码一运行，所有执行结果是：全走的是同步函数，        //因为线程1启动完之后，瞬间，主线程已经把flag置成false啦，所以，2个线程都走的是false结果。        //所以，要在这1线程启动完之后，主线程休息一下，就剩1线程在跑，才能看到2个线程分别的效果。        try {            Thread.sleep(10);        } catch (Exception ignore) {        }        t.flag = false;        t2.start();        //运行结果：打印出0的错票。不安全。（此时，同步代码块使用的锁，是自己new的一个obj）        //对错误代码进行分析如下：        //两个前提。1，两个或以上的线程；2，用的是否是同一个锁。        // 后面修改同步代码块中的同步对象由object变成this，然后就安全啦。        //        //这个修改完之后，就可以看到，没有输出0啦，而且2个线程，确实都执行了不同的同步实现。一个同步代码块，一个同步函数。        //Thread t3 = new Thread(t);        //Thread t4 = new Thread(t);        //t3.start();        //t4.start();    }    private static void testStatic() {        TicketStatic t = new TicketStatic();        Thread t1 = new Thread(t);        Thread t2 = new Thread(t);        t1.start();        //这时候，没有添加下面的sleep的时候，代码一运行，所有执行结果全走的是同步函数，        //因为线程1启动完之后，瞬间，主线程已经把flag置成false啦，所以，都走的是false结果。        //所以，要在这1线程启动完之后，主线程休息一下才能看到2个线程分别的效果。        try {            Thread.sleep(10);        } catch (Exception ignore) {        }        t.flag = false;        t2.start();        //运行结果：打印出0的错票。不安全。（这个时候，同步代码块使用的锁，是自己this）        //静态方法使用的锁和同步代码块使用的锁不一样。静态同步函数使用的锁是类.class        //对错误代码进行分析如下：        //两个前提。1，两个或以上的线程；2，用的是否是同一个锁。        // 后面修改同步函数中的同步对象由this变成.class，然后就安全啦。        //        //这个修改完之后，就可以看到，没有输出0啦，而且2个线程，确实都执行了不同的同步实现。一个同步代码块，一个同步函数。    }}

在main方法里面看到了2个测试方法。

那么再看看这另一个票的代码实现。

package com.lxk.threadTest.ticket.implement;/** * 测试：静态同步函数和非静态的差别 * <p> * Created by lxk on 2017/6/25 */public class TicketStatic implements Runnable {    private static int tick = 100;    boolean flag = true;    public void run() {        if (flag) {            while (true) {                //synchronized (this) {//静态同步函数使用的是类对象。                synchronized (TicketStatic.class) {//内存中没有本类对象，但是一定有该类对应的字节码文件对象。类名.class                    if (tick > 0) {                        try {                            Thread.sleep(10);                        } catch (Exception ignore) {                        }                        System.out.println(Thread.currentThread().getName() + "....sale...代码块 : " + tick--);                    }                }            }        } else {            while (true) {                show();            }        }    }    private static synchronized void show() {//静态方法的时候，使用的锁就不是this，经测试，可发现使用的是类.class        if (tick > 0) {            try {                Thread.sleep(10);            } catch (Exception ignore) {            }            System.out.println(Thread.currentThread().getName() + "....sale...函数 : " + tick--);        }    }}

这2个一起的原因，就是测试一下一般的同步函数和静态的同步函数，他们加锁的对象是谁。

经过测试，一般的普通同步函数，可以对this加锁，因为从代码可以看出来，这2个线程操作的都是同一个对象。

在上面最开始的以继承的方式实现多线程的第一个例子里面，是四个线程都各自操作各自的对象。

但是，那个票，是静态的，那么，静态的东西是属于类的，所以，虽然有四个对象，但是他们都操作的是一个共同的数据，那就得考虑线程安全问题，那就得考虑如何同步。

在这个实现runnable接口来实现多线程卖票的2个例子。

差别在这个地方。

一个是静态的，一个是非静态的，静态方法只能操作静态变量，所以，在第二个类里面，票变量被声明为静态的。第一个则不用。

而且，对于实现runnable接口的第一个票的例子，

发现2个线程，加锁的对象要相同，才能实现线程安全。

对于实现runnable接口的第二个票的例子，

发现，对于静态的方法而言，加锁的对象，就应该是类.class，这样才能线程安全。

有兴趣的小伙伴 可以把代码直接拿出来，自己测试一下，看看具体执行效果。更好的加深下理解。