java线程

1， Java中编写多线程程序和其他的编程语言相比容易很多。主要通过Runnable接口和Thread类来实现。

publicclassSimpleRunnable implements Runnable{
   private String message;
   publicstaticvoid main(String[] args) {
      SimpleRunnabler1 = new SimpleRunnable("Hello");
      Threadt1 = new Thread(r1);
      t1.start();
      for(;;){
         System.out.println("Bye-bye");
      }
   }
   public SimpleRunnable(String message){
      this.message = message;
   }
   @Override
   publicvoid run() {
      for(;;){
         System.out.println(message);
      }
   }
}

以上，通过继承于Runable接口实现run()来实现多线程，通过Thread来实现虚拟CPU，让线程r1在独立的线程中运行。事实上，该线程和主线程并不是完全的独立运行的线程，而是r1线程和主线程轮番切换运行，只是切换的运行速度特别快，看上去像是两个线程独立运行。

2， 线程的切换，根据不同的操作系统而有所不同：

一种是排队机制，如果一个线程抢得了CPU，直到该线程运行结束，或者被动停止才推出。

一种是通过优先级模式，优先级最高的线程优先抢到CPU。

一种是时间片，每一个线程拥有公平的时间片，当一个线程运行完时间片后退出，其他的线程拥有公平的机会抢占CPU。

Java的线程采用基于优先级和时间片综合的方式，具体实现根据运行的操作系统而有所不同。比如说当一个线程时间片运行完后退出并将优先级降一级，然后排序优先级比较高的线程抢占CPU，如果运行的过程中来了一个优先级更高的线程，则会抢占当前的CPU。

3， 线程运行状态：

线程停止（Pause）包括，sleep()，wait()，suspend()，I/O blocking

线程重启（Run）包括，sleep time-out，notify()，resume()，I/O finished

线程终止，stop()

线程等待，join()

线程主动让出CPU，yield()

以上suspend()，resume()，stop()都已过时，不再建议使用。

4， 其中sleep()函数是static的，是属于类的函数，而不是对象。该函数将使调用的线程暂停一定时间，而不是某一个其他的线程停止。如下

publicstaticvoidmain(String[] args)throwsException {
      SimpleRunnabler1 = new SimpleRunnable("Hello");
      Threadt1 = newThread(r1);
      t1.start();
      for(inti = 0; i < 10; i++){
         System.out.println("Bye-bye");
      }
      t1.sleep(10000);
      t1.stop();
}

以上代码是使主线程停止10秒钟，而不是使t1停止10秒钟。另外sleep()使线程暂停的时间是个模糊值，以上理论将使主线程暂停10秒钟，但是由于线程切换的不确定性，导致主线程并不是精确的暂停10秒钟。

5， 另外一个static的函数是yield()，他表示当前正在运行的线程主动让出CPU，该函数也是仅仅能作用于当前线程类似于以上sleep()函数。

6， 编程是为了追求高效的结果，采用多线程。但是多线程运行是很难预测的，因此我们会采取一定的方法，让多线程的运行结果尽量可预测。

class Thread1 extends Thread{
   @Override
   publicvoid run(){
      try{
         System.out.println("thread1 start");
         sleep(10000);                  // <3>
         System.out.println("thread1 finish");//<4>
      }catch(Exception e){
      }
   }
}
class Thread2 extends Thread{
   @Override
   publicvoid run(){
      try{
         System.out.println("thread2 start");
         suspend();                  // <2>
         System.out.println("thread2 finish");// <7>
      }catch(Exception e){
      }
   }
}
publicclassThreadTest {
 
   publicstaticvoid main(String[] args) {
      Threadt1 = new Thread1();
      Thread2t2 = new Thread2();
      t1.start();
      t2.start();
      try{
         System.out.println("s1");
         t1.join();                  // <1>
         System.out.println("s2");      // <5>
         t2.resume();                //<6>
         System.out.println("s3");      // <8>
         t2.join();                  // <9>
      }catch(Exception e){
      }
      System.out.println("s4");         // <10>
   }
}

以上运行其中一次的运行结果为：

thread1 start

thread2 start

s1

thread1 finish

s2

s3

thread2 finish

s4

但是并不是每次都得到这样的结果。但是也有一部分是可预测的。哪些是可预测的？哪些是不可预测的？

（1） 前三行一定会占据前三行，由于<1>的代码使主线程停止，等待线程t1运行结束，而t1线程在<3>处使线程暂停10秒钟，同时<2>处代码是线程t2处于挂起状态，知道有代码唤醒该线程，否则该线程就会一直处于阻塞状态。但是前三行的输出顺序是不可预测的。

（2） 第四行一定会在第四行，当t1休眠结束后，首先运行<4>处代码

（3） 第五行一定会在第五行，当t1线程运行结束后，主线程获得CPU开始运行代码<5>

（4） 第六行和第七行的位置可能会互换，当代码<6>唤醒线程t2后从<7>开始运行，同时主线程继续运行<8>

（5） 最后一行一定会在最后一行。在<9>暂停主线程，等待t2运行结束，运行<10>输出最后一行，主线程结束退出。