07---多线程02

 

1.线程的生命周期：
 通过继承Thread类或者实现Runnable接口"创建一个线程"----》通过start()方法"启动"，但不是立刻启动
 -----》而是进入"就绪状态"-------》cpu调用时进入"运行状态"-----》结束；
 在运行状态时如果遇到堵塞则进入"堵塞状态"-------》堵塞解除后进入 "就绪状态"
 -------》等待cpu的调度，调用进入"运行状态" 就这样直到结束；
 
 注意：线程启动后不是立刻执行，中间有个等待的时间，等待cpu的调用；

 所有的线程的操作就是值得Thread类的操作；
 当前运行的线程可以指当前操作这个方法的线程；
 
2.取得当前运行的线程：
 public static Thread currentThread()

3.取得线程的名称:
 使用getName方法读取当前的名字。

4.设置线程的名字：
 使用setName方法可以设置指定对象的名字；

注意：一般在创建线程的时候就为其附上名字，最后不要再有了线程后在为其赋名称；
 // 现实Runnable接口
 class Demo01 implements Runnable{
  public void fun(){
   System.out.println(Thread.currentThread().getName());
   }
  public void run(){
   for(int i=0;i<10;i++){
    this.fun();
    }
   }
  }
  
 public class Demo{
  public static void main(String args[]){
   Demo01 d=new Demo01();
   Thread t1=new Thread(d);
   Thread t2=new Thread(d);
   Thread t3=new Thread(d);
   //为存在的线程赋名称
   t1.setName("线程1");
   t2.setName("线程2");
   t3.setName("线程3");
   
   //创建线程时就为其赋名称
   //Thread t1=new Thread(d,"线程1");
   //Thread t2=new Thread(d,"线程2");
   //Thread t3=new Thread(d,"线程3");
   
   
   t1.start();
   t2.start();
   t3.start();
   }
  }
 注意：一个线程对应一个run()，并切这个run()只属于这个线程；如果想实现资源共享，
  必须将资源放到 run()的外面；下面就能实现资源共享：
 // 现实Runnable接口
 class Demo01 implements Runnable{
  int i=10;
  public void fun(){
   System.out.println(Thread.currentThread().getName());
   }
  public void run(){
   while(i>0){
    this.fun();
    i--;
    }
   }
  }
  
 public class Demo{
  public static void main(String args[]){
   Demo01 d=new Demo01();
   Thread t1=new Thread(d);
   Thread t2=new Thread(d);
   Thread t3=new Thread(d);
   //为存在的线程赋名称
   t1.setName("线程1");
   t2.setName("线程2");
   t3.setName("线程3");
   
   //创建线程时就为其赋名称
   //Thread t1=new Thread(d,"线程1");
   //Thread t2=new Thread(d,"线程2");
   //Thread t3=new Thread(d,"线程3");
   
   
   t1.start();
   t2.start();
   t3.start();
   }
  }
结论：main方法也是一个线程，所以之前的所有程序都是基于多线程的运行机制；
 在main方法中通过 对象.(点)方法是主线程；

5.isAlive()方法，判断线程是否已经start；
 isAlive()方法，此方法在线程之后判断，结果没有固定的内容，因为线程有可能优先执行完，
 也有可能最后执行；

6.线程的休眠：
 使用Thread类之中的sleep方法，此方法用于将线程短暂休眠；
 public static void sleep (long millis) throws InterruptedException
 
 // 现实Runnable接口
 class Demo01 implements Runnable{
  public void fun(){
   for(int i=0;i<10;i++){
    try{
      Thread.sleep(1000);
     }
    catch(Exception e){
     
     }  
    System.out.println(Thread.currentThread().getName());
    }
   }
  public void run(){
   this.fun();
   } 
  }
  
 public class Demo{
  public static void main(String args[]){
   Demo01 d=new Demo01();
   Thread t1=new Thread(d,"线程1");
   Thread t2=new Thread(d,"线程2"); 
   t1.start();
   t2.start();
   
   
   }
  }

7.线程的强制执行：
 线程中使用join方法，用于强制某一线程执行；
 public final void join() throws InterruptedException

 // 现实Runnable接口
 class Demo01 implements Runnable{
  public void run(){
   for(int i=0;i<20;i++){
   System.out.println(Thread.currentThread().getName()+"---》运行i="+i);
   }
  } 
 }
 
 public class Demo{
  public static void main(String args[]){
   Demo01 d=new Demo01();
   Thread t=new Thread(d,"线程1"); 
   t.start();
   for(int i=0;i<10;i++){
    if(i==5){
     try{
       //强制线程执行
       t.join();
      }
     catch(Exception e){
      }
     
     }
    System.out.println(Thread.currentThread().getName()+"---》运行i="+i);
    }
   }
  }
 以上的运行结果是：main线程和线程1两个线程交替执行，当执行到i等于5时，这时 只强制执行线程1了 ，
     当线程1执行完后在执行main线程；