多线程笔记

【掌握的】

1.两种方式创建线程：（继承，实现）

2.继承和实现的区分

3.线程的生命周期 

4.不同状态下，所对应的方法。【通过哪些方法，可以让线程达到某个状态。】

5.同步代码块，同步方法。

----------------------

1.学习多线程的原因？

  生活中：

   程序：  一个完整的功能代码。（方法，没有被运行）

   进程：  一个完整的功能代码。（方法，被运行）

   线程：  进程包含线程。

  好处：提高代码的执行效率。总是有一些功能是需要同时执行的，那就需要多线程。

2.主线程：
 
   -----执行main方法里的代码。

  普通线程
   ------run 方法里的代码。

3.完成线程的步骤：

   A. 编写线程类：（1.通过继承）

   B. 重写run方法：

   C. 创建线程对象，调用start方法，开启线程。

  补充：

   （1） 线程对象.run();  没有开启线程，只是在调用线程对象的run（）方法。                  
         线程对象.start(); 线程开启的标志，自动调用run（）方法
   
   （2） 调用start（）方法就立刻执行run（）方法吗？

        线程对象.start(); ----当前线程所处的状态是“就绪状态”

             真正执行run();----当前线程所处的状态是“运行状态”

        ----“就绪状态” 和“运行状态” 之间，间隔多久，不清楚。
 

   （3）线程  【默认命】和【指定名】。

        普通线程的默认名：Thread-变量    ----变量static的，从0开始计数

            主线程默认名：main

        
         // private String name;   //1.接收外界传入的参数，完成线程名。
  // public Thread1(String name){
  //   this.name=name;
  // }
 
   public Thread1(String name){//2.调用父类有参，完成线程命名。
    super(name);
   }

 public void run() {
     // Thread.currentThread().setName(name);
  for (int i = 1; i <= 10; i++) {
   System.out.println
   (Thread.currentThread().getName()+"--->"+i);
  }
 }

  【2.通过实现完成线程】
    
   A.编写线程类：

   B.。重写run（）方法

   C。创建线程实现类对象，

       创建线程对象，

       线程对象调用方法，开启线程。

      
   补充： （1.） Thread 实现 Runnable接口
 
          （2.）Thread  th

                Thread2  th2
          都实现Runnable接口 ，在th .start（）；---th2.run()被执行。【代理模式】
    

          （3.）继承方式， VS 实现方式  哪种线程类更好？

                 实现方式 好：

                 1.可以多实现

                 2.数据共享。

                【例子：3个窗口同时销售5张火车票】
               
            
                【继承方式：】
public class ThreadPiao extends Thread {
        private int piao=5;
 
 public void run() {
  
    for(int i=1;i<=100;i++){
     if(piao>0){
      System.out.println
      (Thread.currentThread().getName()+"---"+piao--);
     }
    }
 
 }
}
 
      【测试代码】
                new ThreadPiao().start();
  new ThreadPiao().start();
  new ThreadPiao().start();

 

              【实现方式】
public class ThreadP implements Runnable {

 private int piao=5;
 
 public void run() {
   for(int i=1;i<=100;i++){
      if(piao>0){
       System.out.println
       (Thread.currentThread().getName()+"---"+piao--);
      }
     }
 }

}
          【测试代码】
                ThreadP tp=new ThreadP();
  new Thread(tp).start();
  new Thread(tp).start();
  new Thread(tp).start(); 

    问题：继承方式，可不可以只new 1个线程对象，然后调用3次start（）方法？

       

 

4.线程状态/生命周期：
   A.新生状态：   new 线程类（）；
   B.就绪状态：   start（）；  【有被执行的资格，但是还没有被cpu调度；队列】
   C.运行状态：   run（）；   
   D.阻塞状态：  sleep（）：  礼让 yi  （）；  强制 join(）；
   D.死亡状态：A。正常线程结束 B。发生异常，产生异常对象，没有被截获。

              C。线程自身调用了Stop（）。---不被使用

 4.1新生状态：
  
     创建线程对象，可以调用无参,有参（给线程命名）
     ---可以获得到的信息：

       1.获得线程对象。名字 Thread.currentThread().getName()

       2.设置或获得当前线程的优先级：
         th.setPriority(9);
  System.out.println("线程优先级最大是："+Thread.MAX_PRIORITY);
  System.out.println("线程优先级最大是："+Thread.MIN_PRIORITY);
  System.out.println("th1的线程优先级是："+th.getPriority());
  
   4.2就绪状态：

        是否处于就绪状态：Thread.currentThread().isAlive()
        
   4.3运行状态：

     程序执行run();【有被执行的资格，同时也被CPU调度。但是至于什么时间被执行的，不清楚】

  4.4阻塞状态：

      【线程强制执行：join()】

      for (int i = 1; i <=10; i++) {
   if(i==3){
    try {
     th.join();
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
   }
         System.out.println(Thread.currentThread().getName()+"--"+i);
  }
         说明：普通线程强制抢占了cpu资源。

               主线程：由原来的运行状态----》阻塞状态---就绪状态---运行状态

               普通线程：直接运行结束。

         使用场合：线程有明确的【完成先后顺序】。  
   

      【线程休眠：sleep（）】

           for (int i = 1; i <=10; i++) {
   if(i==3){
     Thread.sleep(3000);//单位是毫秒
   }
         System.out.println(Thread.currentThread().getName()+"--"+i);
    }

        说明：（1）当前线程休眠：由原来的运行状态----》阻塞状态---就绪状态---运行状态
                   ---休眠时间结束，进入到就绪状态，等待cpu调度。

              （2）中途阻止休眠：（了解）    
                   【例子：】
                   终止休眠： 1. th.interrupt();
                             2.  在异常捕获的时候，出现return。

      【线程礼让：】

            for (int i = 0; i < 10; i++) {
   if(i==3){
    Thread.yield();
    System.out.println("线程礼让一次");
   }
   System.out.println(i);
  }
             说明：让出当前这次cpu资源：线程状态不阻塞---直接进行就绪状态--运行状态。

5.线程安全：

      多线程同时操作数据资源，会出现数据不正确。所需线程同步。
  

    第一种方式：同步代码块  ---使用在线程中。

 public void run() {
   
 for (int i = 1; i <=100; i++) {
  synchronized(this){
   if(piao>0){
    try {
     Thread.sleep(1000);
    } catch (InterruptedException e) {
     e.printStackTrace();
    }
 System.out.println(Thread.currentThread().getName()+"--"+piao--);
   }
  }
 }
  
 }

 

    第二种方式：同步方法：
         
 public void run() {
   
    for (int i = 1; i <=100; i++) {
  
    maip();
  
   }
  
 }

 

     public synchronized void maip(){
  if(piao>0){
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
 System.out.println(Thread.currentThread().getName()+"--"+piao--);
  }
 }