java多线程 基础(二) Thread Runnable

[线程的并发与并行]
      
          在单CPU系统中，系统调度在某一时刻只能让一个线程运行，虽然这种调试机制有多种形式(大多数是时间片轮巡为主)，但无论如何，要通过不断切换需要运行的线程让其运行的方式就叫并发(concurrent)。而在多CPU系统中，可以让两个以上的线程同时运行，这种可以同时让两个以上线程同时运行的方式叫做并行(parallel)。
       [ 并发：(1)在CUP空闲的时候可以对某一个线程时行调度，运行
                     (2)当某一线程运行一部分后需要另一线程产生的结果,才能运行下去。
        并行： 在多cup的情况下可以同时运行两个以上的线程的进候属于并行， 这些线程这间是独立的，并没有太多                     的联系    
      ]
 
    [JAVA线程对象]
         在JAVA中，要开始一个线程，有两种方式。
        一 是直接调用Thread实例的start()方法
       二  将Runable实例传给一个Thread实例然后调用它的start()方法。

        生成一个线程的实例，并不代表启动了线程。而启动线程是说在某个线程对象上启动了该实例对应的线程，当该线程结束后，并不会就立即消失。
       示例一 ：

public class SongThread extends Thread{
   
    private int x=0;
   
    public void run(){
       
        for(int i=0;i<100;i++){
            try {
                Thread.sleep(1);
                System.out.println(x++);
            } catch (InterruptedException e) {
            System.out.println(x++);
            }          
        }   

    }
   

    //测试1：单独调动已经实例化的线程类。线程类SongThread并不是main中的主线程。所以会先运行system.out.println();
    public static void main(String[] args){
        SongThread songthread=new SongThread();
        songthread.start();
        System.out.println("songqiu");       
    }
   
    //测试2：把SongThread类加入main主线程   
//    public  static  void main(String[] args){
//        System.out.println("songqiu");   
//        SongThread songthread=new SongThread();
//        songthread.start();
//        try {
//            songthread.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//        System.out.println("songqiu");
//    }

   
    //测试3：当线程类SongThread调用过一次start()方法后，然后在去调用一次start()，这个时候去发生异常
    //异常产生的原因是:继承Thread抽象类的类，启动线程类只能产生一个线程，当这个线程类调用start()方法后，会自动结束线程的生命周期
//   public static void main(String[] args){
//       SongThread songthread =new SongThread();
//   
//       System.out.println("第一次调用线程songthread : 开始......");
//       songthread.start();
//       try {
//        songthread.join();
//        Thread.sleep(5000);
//      } catch (InterruptedException e) {
//        e.printStackTrace();
//      }
//      System.out.println("第一次调用线程songthread结束！");
//      System.out.println("=================");
//     
//      System.out.println("第二次调用线程songthread : 开始......");
//      try{
//      songthread.start();
//      System.out.println("第二次调用线程songthread结束！");
//      }catch(IllegalThreadStateException e){         
//          System.out.println("第二次调用线程时发生异常!");         
//      }
//   }

}

       示例二：


public class SongRunnable implements Runnable{

    private int x=0;
   
    public void run() {

        for(int i=0;i<100;i++){
            try {
                Thread.sleep(1);
               System.out.println(x++);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }   
    }
   
   
    //测试1：此类继承了接口Runnable，然后去实现run()方法，但此类要产生线程的话必须用Thread抽象类去包装
    //此方法任可以加入main主线程
    public static void main(String[] args){
        new Thread(new SongRunnable()).start();
    }

   
    //测试2：产生多个线程，线程可以利用存贮区域里的变最
//    public static void main(String[] args){
//        SongThread songthread=new SongThread();
//       
//        for(int i=0;i<2;i++){
//       
//         System.out.println("第"+(i+1)+"调用线程,开始...");
//         Thread threadRunnable    =new Thread(songthread);
//         threadRunnable.start();
//         try {
//            threadRunnable.join();
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
//           
//            System.out.println("第"+(i+1)+"调用线程结束。");
//            System.out.println("==============================");
//        }
//    }
}