黑马程序员-线程（2）

-------------------android开发、java培训、期待与您交流！ ----------------------

黑马程序员-线程

在java中，并发机制非常重要，但是并不是所有的程序语言都支持线程。在以往的程序中，多以一个任务完成以后在进行下一项目的模式进行开发，这样下一个任务的开始必须等待上一任务的结束。Java语言提供了并发机制，程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其它线程并发执行，这种机制被称为多线程。一个线程则是进程中的执行流程，一个进程可以同时包括多个线程，每个线程也可以得到一个段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。在单线程中，程序代码按照调用的顺序依次只执行下去，如果需要一个进程同时完成多段代码的操作，就需要产生多线程。

在java中主要提供两种方式实现线程，分贝为继承java.lang.Thread类与实现java.lang.Runnable接口。

Thread类是java.lang包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新的线程需要建立Thread。Thread的构造方法有两种：(1)public Thread(String  threadName)，是创建一个名称为threadName 的线程对象。(2)public Thread()。

完成线程真正功能的代码放在类的run()方法中，当一个类继承thread类后，就可以在该类中覆盖run()方法，将实现该线程功能的代码写入run()方法中，然后同时调用Thread类中的start()方法执行线程，也就可以调用run()方法。

如果程序员需要继承其他类而且还要是当前类实现现多线程，那么就可以通过Runnable接口来实现。通过Runnable接口创建线程时程序员首先需要编写一个实现Runnable接口的类，然后实例化该类实现的对象，这样就构建了Runnable对象。

线程的生命周期分别包括：出生状态，就绪状态，运行状态，等待状态，休眠状态，阻塞状态和死亡状态。出生状态就是线程被创建时的状态，在用户使用线程实例调用start()方法之前线程处于出生状态，当用户调用start()方法之后，线程处于就绪状态，当现成的到系统资源后进入运行状态。一单线程进入执行状态他会在就绪与运行状态下转换，同时也可以进入等待、休眠、阻塞或者死亡状态。当处于运行状态下的线程调用Thread类中的wait()方法时，该线程进入等待状态，进入等待状态的线程必须调用Tread类中的notify()方法才能被唤醒，而notifyAll()的方法时将所有处于等待状态的线程唤醒，当线程调用Thread类中的sleep()方法时，则进入休眠状态，如果一个线程在运行状态下发出输入、输出请求，该线程将进入阻塞状态，在等待输入、输出线程结束时线程进入就绪状态，对于阻塞的线程来说，即使系统空闲，线程依然不能回到运行状态。当线程的run()方法执行完毕时，线程进入死亡状态。

下边是生产者、消费者多线程的运行机制代码：

import java.util.concurrent.locka.*;

class Resource

{

    private String name;

    private int count=1;

    private boolean flag=false;

    private Lock lock=new ReentrantLock();//创建一个锁对象

    private Condition condition_pro=lock.new Condition();//创建一个升级版本的Condition锁对象

    private Condition condition_con=lock.new Condition();//创建另外一个升级版本的Condituon锁对象

 

    public void set(String name)throws InterruptedException//抛出中断异常

    {

       lock.lock();//加锁

       try

       {

           while(flag)//当多个生产者线程过来时，都需要先判断flag值，若为true则等待

           condition_pro.await();//生产者等待

           this.name=name+"--"+count++;

           System.out.println(Thread.currentThread().getName()+"...生产者..."+this.name);

                           //输出当前线程的名字，标记为生产者，加上产品的名字

           flag=true;//生产产品后将flag值改为true，表明已经生产过产品未消费

           condition_con.signal();//唤醒消费者，来消费产品

       }

       finally//一定要执行的操作

       {

           lock.unlock();//释放锁

       }

    }

    public void out()throws InterruptedException//抛出中断异常

    {

       lock.lock();//加锁

       try

       {

           while(!flag)//当多个消费者线程过来时，需要先判断flag的值，若为false则等待

              condition_con.await();//消费者等待

           System.out.println(Thread.currentThread().getName()+"...消费者.............."+this.name);

           flag=false;//消费者消费完产品后修改flag值

           condition_pro.signal();//唤醒生产者，来生产产品

       }

       finally//一定要执行的操作

       {

           lock.unlock();//释放锁的动作一定要执行

       }  

    }

}

Thread类中的setDaemon(true)设置一个线程为后台线程，该方法必须在线程启动之前调用，也就是在调用start()方法之前调用。
如果一个进程中只有后台线程在运行，这个进程就会结束。

thread1.join()的作用是把thread1所对应的线程合并到调用thread1.join()的线程中。

yield()方法可以让当前正在运行的线程对象临时暂停，让别的线程运行。

sleep(...)方法可以让当前正在运行的线程进入睡眠状态。

获取和更改线程的优先级分别用Thread对象的getPriority()方法和setPriority(int newPriority)方法。线程的默认优先级的值是5。

创建一个线程类有两种方法：
1，直接继承Thread类；
2, 实现Runnable接口，然后用new Thread(实现Runnable接口的类的对象)来产生一个线程类。

使用Runnable接口创建多线程，适合多个相同程序代码的线程去处理同一份资源的情况。还可以避免由于java的单继承特性带来的局限。
事实上，几乎所有的多线程应用都可用Runnable接口方式。

每个线程都会有一个运行的时间片，都会有开始和时间片到期的时候。
所以我们要注意了：一个线程的时间片到期的时候，此线程有可能执行到程序的任何一个位置而被暂停，并没有完全执行完一个原子性的模块，
然后就进入时间片的轮换，这样就导致多线程的运行结果不可意料。此时我们就需要对线程进行同步处理。

线程同步关键字是：synchronized

同步代码块放在如下的大括号中：
synchronized(obj){     //用于synchronized的obj叫lock旗标(锁旗标)，可以是任何对象，我们通常称之为同步对象或者监视器对象。
}

同步方法只须在方法前加synchronized关键字修饰即可。
同步非静态方法的监视器是this，而同步静态方法的监视器是当前所在的类的Class对象。

只要使用相同的同步对象(监视器)，synchronized方法和synchronized代码块也可以实现同步。

在编写多线程同步的时候一定要注意避免死锁的发生。

class Producer implements Runnable//创建生产者类，实现Runnable接口

{

    private Resource res;

    Producer(Resource res)//构造代码块

    {

       this.res=res;

    }

    public void run()//覆盖run方法

    {

       while(true)

       {

           try

           {

              res.set("+商品+");

           }

           catch (InterruptedException e)//处理异常

           {

           }

       }

    }

}

class Consumer implements Runnable//创建消费者类，实现Runnable接口

{

    private Resource res;

    Consumer(Resource res)//构造代码块

    {

       this.res=res;

    }

    public void run()//覆盖run方法

    {

       while(true)

       {

           try

           {

              res.out();

           }

           catch (InterruptedException e)//处理异常

           {

           }

       }

    }

}

class ProducerConsumerDemo //创建ProducerConsumerDemo类

{

    public static void main(String[] args) //主方法

    {

       Resource res=new Resource();//创建资源对象

       new Thread(new Producer(res)).start();//创建生产者线程并开启线程

       new Thread(new Consumer(res)).start();//创建消费者线程并开启线程

       new Thread(new Producer(res)).start();//创建生产者线程并开启线程

       new Thread(new Consumer(res)).start();//创建消费者线程并开启线程

       //创建两个生产者线程，两个消费者线程

    }

}

如果上面的两个while块里面的代码分别由两个线程执行，那么就形成了死锁。

我们在编写线程安全的程序代码的时候也必须防止一个线程对共享的数据仅仅做了部分的操作的时候，这个线程就结束了，这种情况下就会破坏数据的一致性。

要实现同步的线程所检查的监视器对象必须是同一个对象，才能保证线程的同步。

不同的类中的方法或者语句块也可以实现同步，只要是同一个监视器对象就可以了。

多线程编程里面的run()方法里面通常都是一个while循环程序。

Object类里面有几个方法是用于线程通信的：wait()，notify()，notifyAll()。由于任何对象都可以作为监视器对象，所以任何对象都可以调用这几个方法。
但是这些方法只能在被synchronized修饰的方法或者代码块中调用。
每个对象除了有一个锁旗标之外，还有一个线程等待队列（wait set），一个对象刚创建的时候，它的等待队列是空的。

如果一个线程里面有while循环，我们可以设置一个boolean flag变量作为while的循环条件，while(flag)，
当我们需要结束这个线程的时候就可以在另外一个线程中将这个flag设置为false即可。

 

/*

JDK1.5中提供了多线程升级解决方案

将同步中的waiat.notify.notifyAll替换成了Condition对象

该对象可以用Lock锁进行获取

该实例中，实现了本方只能唤醒对方的操作

*/

-------------------android开发、java培训、期待与您交流！ ----------------------