多线程开发

参考资料：

参考1：java开发实战经典

参考2：Java 线程池学习

1.多线程概述

要实现多线程可以通过继承Thread和实现Runnable接口。不过这两者之间存在一些区别。其中最重要的区别就是，如果一个类继承Thread类，则不适合于多个线程共享资源，而实现了Runnable接口，就可以方便地实现资源的共享。

范例1：继承Thread类不能资源共享

View Code package test;public class MyThreadDemo1 {    public static void main(String args[]) {        MyThread1 mt1 = new MyThread1();        MyThread1 mt2 = new MyThread1();        MyThread1 mt3 = new MyThread1();        mt1.start();        mt2.start();        mt3.start();    }    static class MyThread1 extends Thread {        private int ticket = 5;        @Override        public void run() {            // TODO Auto-generated method stub            for (int i = 0; i < 100; i++)                if (ticket > 0)// 当余票大于0则买票                {                    System.out.println("卖一张票：剩余ticket=" + --ticket); // 这里--ticket表示卖了一张票后的余票                }        }    }}

程序运行结果：

View Code 卖票：剩余ticket=5卖票：剩余ticket=4卖票：剩余ticket=3卖票：剩余ticket=2卖票：剩余ticket=1卖票：剩余ticket=5卖票：剩余ticket=4卖票：剩余ticket=3卖票：剩余ticket=5卖票：剩余ticket=4卖票：剩余ticket=3卖票：剩余ticket=2卖票：剩余ticket=1卖票：剩余ticket=2卖票：剩余ticket=1

以上程序通过继承Thread类实现多线程，程序中启动了三个线程，但是三个线程分别买了各自的5张票，并没有达到资源（Ticket）共享的目的。

范例2：实现Runable接口可以资源共享

View Code package test;public class MyRunableThreadDemo1 {    public static void main(String args[]) {        MyRunableThread1 mrt = new MyRunableThread1();        Thread t1 = new Thread(mrt);        Thread t2 = new Thread(mrt);        Thread t3 = new Thread(mrt);        t1.start();        t2.start();        t3.start();    }    static class MyRunableThread1 implements Runnable {        private int ticket = 5;        @Override        public void run() {            // TODO Auto-generated method stub            for (int i = 0; i < 100; i++)                if (ticket > 0)// 当余票大于0则买票                {                    System.out.println("卖一张票：剩余ticket=" + --ticket); // 这里--ticket表示卖了一张票后的余票                }        }    }}

程序运行结果：

卖票：剩余ticket=5卖票：剩余ticket=4卖票：剩余ticket=3卖票：剩余ticket=2卖票：剩余ticket=1

 

从程序的运行结果中可以清楚地发现，虽然启动了3个线程， 但是三个线程一共才卖出去5张票，即ticket属性是被所有线程所共享的。

可见，实现Runnable接口相对于继承Thrad类来说，有如下显著优势：

1. 适合多个相同程序代码的线程去处理同一资源的情况。
2. 可以避免由于java单继承特性带来的局限
3. 增强了程序的健壮性，代码能够被多个线程共享，代码与数据时独立的。

——————————————————————————————————————

范例2-2：增加输出线程名称的功能（ps：2012-6-9）

假如我们需要知道到底是哪一个线程在卖票，那么我们就必须输出线程的名称，对上述实例进行稍作修改该即可完成

首先是在实例化线程的时候可以传入线程名称，代码如下：

View Code package test;public class MyRunableThreadDemo2 {    public static void main(String args[]) {        MyRunableThread1 mrt = new MyRunableThread1();        Thread t1 = new Thread(mrt, "t1");        Thread t2 = new Thread(mrt, "t2");        Thread t3 = new Thread(mrt, "t3");        t1.start();        t2.start();        t3.start();    }    static class MyRunableThread1 implements Runnable {        private int ticket = 5;        @Override        public void run() {            // TODO Auto-generated method stub            for (int i = 0; i < 100; i++)                if (ticket > 0) {                    System.out.println(Thread.currentThread().getName()                            + "卖了一张票票，剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票                }        }    }}

上述程序运行结果如下：

t1在卖票：剩余ticket=4
t3在卖票：剩余ticket=2
t2在卖票：剩余ticket=3
t2在卖票：剩余ticket=1
t3在卖票：剩余ticket=0

但是多次你运行发现结果各不相同。

————————————————————————————————————————————

2.多线程的同步

多次运行范例2我们发现得到的结果可能都不相同。下面列举两个可能的输出结果

范例2可能的输出结果1

卖票：剩余ticket=4卖票：剩余ticket=5卖票：剩余ticket=2卖票：剩余ticket=3卖票：剩余ticket=1

范例2可能的输出结果2

卖票：剩余ticket=4卖票：剩余ticket=2卖票：剩余ticket=1卖票：剩余ticket=5卖票：剩余ticket=1

为了更形象地说明线程同步，我们在范例2中加入进程延时机制Thread.sleep(300);。代码如下所示：

View Code package test;public class MyRunableThreadDemo2 {    public static void main(String args[]) {        MyRunableThread1 mrt = new MyRunableThread1();        Thread t1 = new Thread(mrt, "t1");        Thread t2 = new Thread(mrt, "t2");        Thread t3 = new Thread(mrt, "t3");        t1.start();        t2.start();        t3.start();    }    static class MyRunableThread1 implements Runnable {        private int ticket = 5;        @Override        public void run() {            // TODO Auto-generated method stub            for (int i = 0; i < 100; i++)                if (ticket > 0) {                    try {                        Thread.sleep(300);                    } catch (InterruptedException e) {                        e.printStackTrace();                    }                    System.out.println(Thread.currentThread().getName()                            + "卖了一张票票，剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票                }        }    }}

再次运行多线程主程序，得到的结果如下：

View Code 卖票：剩余ticket=4卖票：剩余ticket=5卖票：剩余ticket=3卖票：剩余ticket=2卖票：剩余ticket=1卖票：剩余ticket=0卖票：剩余ticket=-1

出现票数为负的情况是因为：

线程1在执行 ticket--之前，线程2 进入了 if (ticket > 0) 这个判断，这样当线程1 ticket--之后ticket==0了，线程2再次执行ticket--那么ticket==-1。相当于多执行了一次 ticket--

3.两种线程同步方法

为了解决范例2中出现的问题，我们通过引入同步机制来解决问题。同步又分为同步代码块和同步方法两种类型。

范例3：同步代码块

View Code package test;public class MyRunableThreadDemo3 {    public static void main(String args[]) {        MyRunableThread1 mrt = new MyRunableThread1();        Thread t1 = new Thread(mrt, "t1");        Thread t2 = new Thread(mrt, "t2");        Thread t3 = new Thread(mrt, "t3");        t1.start();        t2.start();        t3.start();    }    static class MyRunableThread1 implements Runnable {        private int ticket = 200;        @Override        public void run() {            //错误//            synchronized (this) {//                while (ticket > 0) {//                    ////                    try {////                        Thread.sleep(3);////                    } catch (InterruptedException e) {////                        e.printStackTrace();////                    }//                    System.out.println(Thread.currentThread().getName()//                            + "卖了一张票票，剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票//                }//            }            /**             * 同步代码块 之前说到ticket出现负数的原因是线程1在执行 ticket--之前，线程2 进入了 if (ticket > 0) 这个判断，              * 这样当线程1执行 ticket--之后ticket==0了，线程2再去执行ticket--，那么ticket==-1。相当于多执行了一次ticket--，             * 因此我们将synchronized(this)放在了if(ticket>0)之前。for(int i=0;i<100;i++)用来表示连续执行100次。这里synchronized在             * for循环后面，因此每个线程都执行100次，彼此都有可能锁冲突。             * */             for(int i=0;i<100;i++)                    synchronized(this)                    {                        if(ticket>0)                        {                            try{                                Thread.sleep(30);                            }catch(InterruptedException e)                            {                                e.printStackTrace();                            }                            System.out.println(Thread.currentThread().getName()                                    + "卖了一张票票，剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票                        }                    }            }    }}

之前说到ticket出现负数的原因是“线程1在执行 --ticket之前，线程2 进入了 if (ticket > 0) 这个判断， 这样当线程1执行 ticket--之后ticket==0了，线程2再去执行ticket--，那么ticket==-1，相当于多执行了一次ticket--”，

因此我们将synchronized(this)放在了if(ticket>0)之前。我们还可以发现外部有一个执行一般次的for循环for(int i=0;i<100;i++)，这用来表示run方法中的这synchronized代码块会被执行100次。需要注意的是只有执行完synchronized代码块才会释放锁。因此每一个线程都有100次可能出现锁冲突，一个线程需要等待另外一个线程执行完synchronized代码块中的内容以后才可以访问这个代码块。

范例4：同步方法

View Code package test;public class MyRunableThreadDemo4 {    public static void main(String args[]) {        MyRunableThread1 mrt = new MyRunableThread1();        Thread t1 = new Thread(mrt, "t1");        Thread t2 = new Thread(mrt, "t2");        Thread t3 = new Thread(mrt, "t3");        t1.start();        t2.start();        t3.start();    }    static class MyRunableThread1 implements Runnable {        private int ticket = 200;        @Override        public void run() {            for (int i = 0; i < 100; i++) {                sale();            }        }                public synchronized void sale() {            if (ticket > 0) {                try {                    Thread.sleep(30);                } catch (InterruptedException e) {                    e.printStackTrace();                }                System.out.println(Thread.currentThread().getName()                        + "卖了一张票票，剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票            }        }    }}

这里将操作ticket资源的内容单独抽取出来作为一个方法来调用，然后同步该方法，保证同一时间只有一个进程调用该方法。

4生产者消费者案例

范例5：

View Code package test;public class ThreadDeadLock {    public static void main(String args[]) {        Info info = new Info();        // info作为参数传入两个线程当中        ProducerThread pt = new ProducerThread(info);        ConsumerThread ct = new ConsumerThread(info);        Thread producer = new Thread(pt, "producer");        Thread consumer = new Thread(ct, "consumer");        producer.start();        consumer.start();    }        //资源类    static class Info {        private String name = "name";        private String content = "content";        public String getName() {            return name;        }        public void setName(String name) {            this.name = name;        }        public String getContent() {            return content;        }        public void setContent(String content) {            this.content = content;        }    }    // 生产者线程    static class ProducerThread implements Runnable {        private Info info = null;        // 构造函数，其参数是资源        public ProducerThread(Info info) {            this.info = info;        }        @Override        public void run() {            // boolean flag=false;            for (int i = 0; i < 10; i++) {                this.info.setName("name" + i);                try {                    Thread.sleep(90);                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }                this.info.setContent("content" + i);            }        }    }    static class ConsumerThread implements Runnable {        private Info info = null;        // 构造函数，其参数是资源        public ConsumerThread(Info info) {            this.info = info;        }        @Override        public void run() {            for (int i = 0; i < 10; i++) {                try {                    Thread.sleep(100);                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }                System.out.println(this.info.getName() + ":-->"                        + this.info.getContent());            }        }    }}

程序输出：

View Code name1:-->content0name2:-->content1name3:-->content2name4:-->content3name5:-->content4name6:-->content5name7:-->content6name8:-->content7name9:-->content8name9:-->content9

范例5存在两个问题：

1. 问题1：假设ProducerThread线程刚设置了name信息，还没有设置content信息，此时程序就切换到了ConsumerThread线程，那么ConsumerThread线程获取的是当前name与之前的content，所以输出结果会出现（比如：name1:-->content0）。这是因为name与content没有一起设置的原因，或者是说name与content信息不同步。
2. 问题2：生产者放了若干次数据，消费者才开始取数据，或者是，消费者取完一个数据后，还没有等到生产者放入新的数据，又重复取出已去过的数据。（比如出现name1:-->content0 name1:-->content0，这个可以通过调节sleep来控制）

问题1 解决：加入同步

如果要为操作加入同步，可以通过定义同步方法的方式完成，即将设置名称和内容定义在一个方法里面，代码如范例6所示。

范例6

View Code package test;public class ThreadDeadLock2 {    public static void main(String args[]) {        Info info = new Info();        // info作为参数传入两个线程当中        ProducerThread pt = new ProducerThread(info);        ConsumerThread ct = new ConsumerThread(info);        Thread producer = new Thread(pt, "producer");        Thread consumer = new Thread(ct, "consumer");        producer.start();        consumer.start();    }    // 资源类    static class Info {        private String name;        private String content;        //getter and setter        public String getName() {            return name;        }        public void setName(String name) {            this.name = name;        }        public String getContent() {            return content;        }        public void setContent(String content) {            this.content = content;        }        // 获取name与content信息        public synchronized void get() {            try {                Thread.sleep(300);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            System.out.println(this.getName() + ":-->" + this.getContent());        }        // 设置name与content信息        public synchronized void set(String name, String content) {            this.setName(name);            try {                Thread.sleep(300);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            this.setContent(content);        }    }    // 生产者线程    static class ProducerThread implements Runnable {        private Info info = null;        // 构造函数，其参数是资源        public ProducerThread(Info info) {            this.info = info;        }        @Override        public void run() {            for (int i = 0; i < 10; i++) {                this.info.set("name" + i, "content" + i);            }        }    }    static class ConsumerThread implements Runnable {        private Info info = null;        // 构造函数，其参数是资源        public ConsumerThread(Info info) {            this.info = info;        }        @Override        public void run() {            for (int i = 0; i < 10; i++) {                try {                    Thread.sleep(100);                } catch (InterruptedException e) {                    // TODO Auto-generated catch block                    e.printStackTrace();                }                this.info.get();            }        }    }}

程序运行结果

View Code name-0:-->content-0name+1:-->content+1name-2:-->content-2name+3:-->content+3name-4:-->content-4name-6:-->content-6name+7:-->content+7name-8:-->content-8name+9:-->content+9name+9:-->content+9

从程序的运行结果中可以发现，问题1：信息错乱的问题已经解决，但是依然存在问题2：重复读取的问题，以及漏读信息的问题（比如上述输出中name9:-->content9重复读取，而name5:-->content5被漏读了）。既然有重复读取，则肯定会有重复设置的问题，那么对于这样的问题，该如何解决呢？此时，就需要使用Object类。

Object类是所有类的父类，在此类中有以下几种方法是对线程操作有所支持的，如下表所示：

如果想让生产者不重复生产，消费者不重复消费，可以设置有一个标志位，假设标志位为boolean型变量，如果标志位内容为true，则表示可以生产，但是不能取走，如果标志位内容为false，则表示可以取走，不能生产。操作流程如下：

问题解决2——加入等待与唤醒

View Code package edu.sjtu.erplab.thread;class Info{    private String name="name";    private String content="content";    private boolean flag=true;    public  synchronized void set(String name,String content)    {        if(!flag)//标志位为false，不可以生产        {            try {                super.wait();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }        this.setName(name);        try {            Thread.sleep(30);        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        this.setContent(content);        flag=false;//修改标志位为false，表示生产者已经完成资源，消费者可以消费。        super.notify();//唤醒消费者进程    }        public synchronized void get()    {        if(flag)        {            try {                super.wait();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }        try {            Thread.sleep(30);        } catch (InterruptedException e) {            // TODO Auto-generated catch block            e.printStackTrace();        }        System.out.println(this.getName()+":-->"+this.getContent());        flag=true;//修改标志位为true，表示消费者拿走资源，生产者可以生产。        super.notify();//唤醒生产者进程。    }            public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getContent() {        return content;    }    public void setContent(String content) {        this.content = content;    }    }class Producer implements Runnable{    private Info info=null;    public Producer(Info info)    {        this.info=info;    }        @Override    public void run() {        boolean flag=false;        for(int i=0;i<10;i++)            if(flag)            {                this.info.set("name+"+i, "content+"+i);                flag=false;            }            else            {                this.info.set("name-"+i, "content-"+i);                flag=true;            }    }}class Consumer implements Runnable{    private Info info=null;    public Consumer(Info info)    {        this.info=info;    }    @Override    public void run() {        for(int i=0;i<10;i++)        {            try {                Thread.sleep(10);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            this.info.get();        }            }}public class ThreadDeadLock {    public static void main(String args[])    {        Info info=new Info();        Producer pro=new Producer(info);        Consumer con=new Consumer(info);        new Thread(pro).start();        new Thread(con).start();    }    }

程序运行结果：

View Code name-0:-->content-0name+1:-->content+1name-2:-->content-2name+3:-->content+3name-4:-->content-4name+5:-->content+5name-6:-->content-6name+7:-->content+7name-8:-->content-8name+9:-->content+9

 

ps：添加注释，解释Object.wait()与this.wait()（2012-5-12）

View Code package edu.sjtu.erplab.thread;class Info{    private String name="name";    private String content="content";    private boolean flag=true;//标识位，表示生产者是否可以进行生产，true表示可以，false表示不可以。        //生产者线程调用的方法    public  synchronized void set(String name,String content)    {        if(!flag)//如果不可以进行生产，则对Info对象加锁        {            try {                super.wait();//让拥有Info对象的生产者线程进入等待状态                //this.wait();            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }        //如果可以进行生产，则设置name与content属性        this.setName(name);//        try {//            Thread.sleep(30);//        } catch (InterruptedException e) {//            // TODO Auto-generated catch block//            e.printStackTrace();//        }        this.setContent(content);        System.out.println("生产："+this.getName()+":-->"+this.getContent());        flag=false;//修改标志位为false，表示可以消费，不能生产。        super.notify();//唤醒拥有Info对象的线程    }        //消费者线程调用的方法    public synchronized void get()    {        if(flag)//如果flag==true表示可以生产不可以消费，        {            try {                super.wait();//让拥有Info资源的消费者线程进入等待            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }        }//        try {//            Thread.sleep(30);//        } catch (InterruptedException e) {//            // TODO Auto-generated catch block//            e.printStackTrace();//        }        System.out.println("消费："+this.getName()+":-->"+this.getContent());        flag=true;//修改标志位为true，表示消费者拿走资源，生产者可以生产。        super.notify();//唤醒生产者进程。    }        public String getName() {        return name;    }    public void setName(String name) {        this.name = name;    }    public String getContent() {        return content;    }    public void setContent(String content) {        this.content = content;    }    }//生产者线程class Producer implements Runnable{    //生产者线程拥有的资源    private Info info=null;    //构造函数    public Producer(Info info)    {        this.info=info;    }       @Override    public void run() {        boolean flag=false;        for(int i=0;i<10;i++)            if(flag)            {                this.info.set("name+"+i, "content+"+i);                flag=false;            }            else            {                this.info.set("name-"+i, "content-"+i);                flag=true;            }    }}//消费者线程class Consumer implements Runnable{    //消费者线程拥有的资源    private Info info=null;    //构造函数    public Consumer(Info info)    {        this.info=info;    }    @Override    public void run() {        for(int i=0;i<10;i++)        {            try {                Thread.sleep(10);            } catch (InterruptedException e) {                // TODO Auto-generated catch block                e.printStackTrace();            }            this.info.get();        }    }}public class ThreadDeadLock {    public static void main(String args[])    {        Info info=new Info();        Producer pro=new Producer(info);        Consumer con=new Consumer(info);        new Thread(pro).start();        new Thread(con).start();    }    }

运行结果

View Code 生产：name-0:-->content-0消费：name-0:-->content-0生产：name+1:-->content+1消费：name+1:-->content+1生产：name-2:-->content-2消费：name-2:-->content-2生产：name+3:-->content+3消费：name+3:-->content+3生产：name-4:-->content-4消费：name-4:-->content-4生产：name+5:-->content+5消费：name+5:-->content+5生产：name-6:-->content-6消费：name-6:-->content-6生产：name+7:-->content+7消费：name+7:-->content+7生产：name-8:-->content-8消费：name-8:-->content-8生产：name+9:-->content+9消费：name+9:-->content+9