第十三章 多线程 第二讲

第十三章  多线程   第二讲

二  线程的生命周期

   线程是一个动态执行的过程，它也有一个从产生到死亡的过程，这就是所谓的生命周期。

    生命周期的执行过程：

      新建——》就绪——》运行——》死亡

1．生命周期的举例与分析

（1）新建（new Thread）
当创建Thread类的一个实例（对象）时，此线程进入新建状态（未被启动）。
例如：Thread  t1=new Thread();

（2）就绪（runnable）
线程已经被启动，正在等待被分配给CPU时间片，也就是说此时线程正在就绪队列中排队等候得到CPU资源。例如：t1.start();

（3）运行（running）
线程获得CPU资源正在执行任务（run()方法），此时除非此线程自动放弃CPU资源或者有优先级更高的线程进入，线程将一直运行到结束。

（4）死亡（dead）
当线程执行完毕或被其它线程杀死，线程就进入死亡状态，这时线程不可能再进入就绪状态等待执行。

自然终止：正常运行run()方法后终止

异常终止：调用stop()方法让一个线程终止运行

（5）堵塞（blocked）
由于某种原因导致正在运行的线程让出CPU并暂停自己的执行，即进入堵塞状态。

（1）正在睡眠：用sleep(long t) 方法可使线程进入睡眠方式。一个睡眠着的线程在指定的时间过去可进入就绪状态。

（2）正在等待：调用wait()方法。（调用motify()方法回到就绪状态）

被另一个线程所阻塞：调用suspend()方法。（调用resume()方法恢复）

2．线程的优先级

     把线程从就绪状态进入运行状态的过程叫做线程调度。负责调度工作的机构叫做调度管理器

 优先级：线程的优先级的取值范围是1~10，1的优先级最高，默认的优先级是5。
public static  final int MAX_PRIORITY = 10
public static  final int  NORM_PRIORITY = 5
public static  final int  MIN_PRIORITY = 1

``  获取优先级的方法：public final intgetPriority();

设置优先级的方法：public final void setPriority(int newPriority);

 

优先级的创建：MyThread mt =  new MyThread(“thread”,8);

注：“thread”是线程的名字，8 是优先级的设置

注：如果有多个线程在等待，并不是优先级别高的就肯定越早执行，只是获得的机会更对一些，因此在通常情况下，不要依靠线程优先级来控制线程的状态.

    

 

3．在线程调度时，用到的方法有：

 (1)void run()   //创建该类的子类时必须实现的方法

(2)void start() //开启线程的方法

 

(3)static void sleep(long t) //释放CPU的执行权，不释放锁

(4)static void sleep(long millis,int nanos) //（秒数，纳秒数）

 

(5)final void wait()//释放CPU的执行权，释放锁

(6)final void notify()//它与wait()一起使用

 

(7)static void yield()------暂停线程

yield()方法可以对当前线程进行临时暂停（让线程将资源释放出来），允许其它线程的执行。该线程仍处于可运行的状态，不转变为阻塞状态，它的优点是：保证有工作时不会让CPU闲置，主要用于编写多个合作线程，也适用于强制性线程间的合作。

注：在使用此方法时，设置为真或者假，是否可执行,代码显示：

    If(flag){  //此时flag是一个boolean类型的值，传的是true 继续执行，

Thread.yield(); //

}

 

pulbic void run(){

    long start = new Date().getTime();//获取当前的时间并付给long

    for(int i=0;i<1000;i++){

          If(flag){ 

Thread.yield();//暂停线程

For(int j=0;j<3000;j++){

    ;

}

}

long end =  new Date().getTime();

System.out.println(this.getName()+”执行时间”+(end-start));

}

   

 

(8)public final void stop()//结束线程，但由于安全的原因过时

(9)join()----连接线程

    连接线程是指使当前的线程阻塞，让出CPU的位置，从而加入正在等待的线程。

（10）interrupt()方法只是为线程设置了一个中断标记，并没有中断线程的运行，一个线程在别设置了此方法后，仍可以执行，isAlive()返回的是true，如果遇到了此方法抛出异常---InterruptException,会结束程序的运行。

四  线程的同步

   1．为什么需要“线程同步”
线程间共享代码和数据可以节省系统开销，提高程序运行效率，但同时也导致了数据的“访问冲突”问题，如何实现线程间的有机交互、并确保共享资源在某些关键时段只能被一个线程访问，即所谓的“线程同步”(Synchronization)就变得至关重要。

临界资源
多个线程间共享的数据称为临界资源(Critical Resource)，由于是线程调度器负责线程的调度，程序员无法精确控制多线程的交替顺序。因此，多线程对临界资源的访问有时会导致数据的不一致行。

正因为有这些原因，所以在实现多线程同步时，每个对象都应该有个“互斥锁“这个标记用来保证在任一时刻，只能有一个线程访问该对象。关键字synchronized用来与对象的互斥锁联系

 实例：

//使用临界资源

public class Stack1 {

    private char[] data=new char[10];

    private int index=0;

    //堆栈的压入

    public void push(char ch){

        //锁定正在执行的多线程，指会执行这一个，等它执行完之后，在执行等待的线程

        synchronized(this){

       data[index]=ch;

       System.out.println("压入字符"+ch+"-->");//p1

       index++;//每压入一个字符索引下标加1，用于标识栈顶位置

       System.out.println("-->压入"+ch+"操作完成！");

       }

    }

    //堆栈的弹出

    public char pop(){

       index--;

       return data[index];

    }

 

//线程类Runner1中的run()方法向堆栈中压入了字符’c’。

public class Runner1 implementsRunnable{

    private Stack1 s;

    public Runner1(Stack1 s){

       this.s=s;

    }

    @Override

    public void run() {

       // TODO Auto-generated methodstub

       //拖延时间

       for(inti=0;i<5;i++){

           System.out.println(i+"  ");

       }

       s.push('c');

    }

}

//线程类Runner2中的run()方法从堆栈中弹出栈顶字符。

public class Runner2 implementsRunnable {

    private Stack1 s;

    public Runner2(Stack1 s){

       this.s=s;

    }

    @Override

    public void run() {

       // TODO Auto-generated methodstub

       System.out.println("***弹出"+s.pop()+"***");

    }

}

//测试类

public class TestCritical {

    public static void main(String[] args){

       Stack1 s=new Stack1();

       s.push('a');

       s.push('b');

      

       Runner1 r1=new Runner1(s);

       Runner2 r2=new Runner2(s);

       Thread t1=new Thread(r1);

       Thread t2=new Thread(r2);

       t1.start();

       t2.start();

    }

}

2. 同步好处：决了线程安全问题

同步弊端:

降低了运行效率（判断锁是较为消耗资源的）

同步嵌套，容易出现死锁

死锁
两个线程A、B用到同一个对象s(s为共享资源)，且线程A在执行中要用到B运行后所创造的条件。在这种前提下A先开始运行，进入同步 块后，对象s被锁定，接着线程A因等待B运行结束而进入阻塞状态，于是B开始运行，但因无法访问对象s，线程B也进入阻塞状态，等待s被线程A解锁。最终 的结果：两个线程互相等待，都无法运行。