13.3线程的生命周期与线程状态

 

13.3线程的生命周期与线程状态

13.3.1  线程优先级

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

线程的优先级用1-10表示，1表示优先级最高，默认值为5，每个优先级值对应Thread类中的一个公用静态常量

并不是优先级越高就肯定越早执行，只是获得的机会更多一些。

线程优先级的改变实例:

   public static void main(String[] args) {

      MyThread threadA=new MyThread("threadA",8);

      threadA.start();

      MyThread threadB=new MyThread("threadB",2);

      threadB.start();

      MyThread threadC=new MyThread("threadC",7);

      threadC.start();

      try {

        Thread.sleep(3000);

      } catch (InterruptedException e) {

        e.printStackTrace();

      }

      threadA.setPriority(3);

      System.out.println("in main()-threadA.getPriority()="+threadA.getPriority());

     

   }

}

class MyThread extends Thread{

   public MyThread(String name,int i) {//设置线程的名字，设置优先级别

      setPriority(i);

      setName(name);

   }

   public void run(){

      for(int i=0;i<5;i++){                  System.out.println("prioity="+getPriority()+",name="+getName());

        try {

           Thread.sleep(2000);

        } catch (InterruptedException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

        }

      }

   }

 

线程调度

（1）    线程睡眠sleep()

   Label lbl;

   public TimeShow(){

      lbl=new Label();

     

      add(lbl);

      setSize(400,200);

      setVisible(true);

  

   public static void main(String[] args) {

      TimeShow ts=new TimeShow();

      Thread th=new Thread(ts);

      th.start();

   }

   public void run(){

      while(true){

        Date d=new Date();

        lbl.setText(d.toString());

        try {

           Thread.sleep(1000);

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

      }

（2）   暂停线程yield()

   public static void main(String[] args) {

      // TODO Auto-generated method stub

      Thread t1=new MyThread9(false);

      Thread t2=new MyThread9(true);

      Thread t3=new MyThread9(false);

      t1.start();

      t2.start();

      t3.start();

   }

}

class MyThread9 extends Thread{

   private boolean flag;

   public MyThread9(final boolean flag){

      this.flag=flag;

   }

   public void setFlag(final boolean flag){

      this.flag=flag;

   }

   public void run(){

      final long start=new Date().getTime();

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

        if(flag)

           Thread.yield();//让出CPU

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

              ;

           }

      }

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

      System.out.println("\n"+this.getName()+"执行时间:"+(end-start)+"毫秒");

      }

(3)连接线程join()

   调用连接线程join()方法可以使当前短暂执行，等待调用该方法的线程结束后再继续执行本线程。它有以下三种调用格式：

Public final void join() throws InterruptedException

Public final void join(long millis) throws InterruptedException

Public final void join(long millis,int nanos) throws InterruptedException

(4)中断线程interrupt()

   Public void interrupt()

   Public boolean isInterrupted()

   Public static boolean interrupted()

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

结束线程原理---就是让run方法结束。而run方法中通常会定义循环结构，所以只要控制住循环即可

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

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

static void sleep(long millis,int nanos)

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

final void notify()

static void yied()//可以对当前线程进行临时暂停（让线程将资源释放出来）

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

public final void join()//让线程加入执行，执行某一线程join方法的线程会被冻结，等待某一线程执行结束，该线程才会恢复到可运行状态

13.4   线程的同步

线程间共享代码和数据可以节省系统开销，提高程序运行效率，但同时也导致了数据的“访问冲突”问题

多个线程间共享的数据称为临界资源(Critical Resource)

实例，使用临界资源。

 class Tickets {

   public int tickets;

   public Tickets(){

      tickets=10;

   }

}

//访问数据的线程

class TicketsThread extends Thread{

   Tickets t;

   String name;

   public TicketsThread(Tickets t,String name){

      this.t=t;

      this.name=name;

      start();

   }

   public void run(){

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

        System.out.println(name+"抢到了第"+t.tickets+"号票");

        t.tickets--;

        try {

           Thread.sleep(20);

        } catch (InterruptedException e) {

           // TODO Auto-generated catch block

           e.printStackTrace();

        }

      }

   }

}

//测试多线程访问时的问题

public class TestMulThread1{

   public static void main(String[] args) {

      Tickets t=new Tickets();

      TicketsThread d1=new TicketsThread(t, "小王");

      TicketsThread d2=new TicketsThread(t, "小张");

   }

}

由于线程d1和线程d2的并行，所以两人抢到的车票会有相同的，而且还会有不被抢到的车票，这是一个典型的临界资源问题，解决该问题最基本、最简单的思路就是使用同步关键字synchronized.

Synchronized关键字是一个修饰符，可以修饰方法或代码块。其作用就是：对于同一个对象（不是一个类得不同对象），当多个线程都同时调用该方法或代码块时，必须依次执行

上面代码修改如下：

class Tickets1{

   public int tickets;

   public Tickets1(){

      tickets=10;

   }

   public synchronized void action(String name){

      System.out.println(name+"抢到了第"+tickets+"号票");

      tickets--;

   }

 

public void run(){

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

        t.action(name);

        try {

           Thread.sleep(20);

        } catch (InterruptedException e) {

           e.printStackTrace();

        }

      }