多线程初级学习1

多线程初级学习

1. 线程与进程的区别

进程：每个正在系统上运行的程序都是一个进程，每个进程包含一到多个线程。

线程：是程序执行流的最小单元，一个标准的线程由线程ID，当前指令指针PC，寄存器集合和堆栈组成。线程是进程中的一个实体，是被系统独立调度和分派的基本单位。

总结:进程是所有线程的集合，每一个线程是进程中的一条执行路径。

2. 为什么要使用多线程？

一个人打一百斤谷子和五个人打一百斤谷子的时间差。
其实就是为了提升程序的执行效率。

3. 多线程应用场景

   秒杀系统，迅雷多线程下载等

4. 同步和异步
   同步就是单个线程，代码从上往下执行如下图

5. 线程创建方式
   1.继承Thread类重写run方法

class CreateThreadExtendsThread extends Thread{
   @Override
   public void run(){
       for(int i=0; i<20; i++){
           System.out.println("run:i==="+i);
       }
   }
}

public class CreateThreadExtends {

   public static void main(String[] args){

       //1.实例化对象
       CreateThreadExtendsThread ce = new CreateThreadExtendsThread();

       //2.启动线程，注意不是调用run()方法
       //ce.run();
       ce.start();
       for (int i=0; i<20; i++){
           System.out.println("main i==="+i);
       }

   }
}

2. 实现Runnable接口

class CreateThreadImplementsRunnable implements Runnable {

  @Override
  public void run(){
      for(int i=0; i<20; i++){
          System.out.println("run:i==="+i);
      }
  }
}

public class CreateThreadRunnable {
  public static void main(String[] args){

      //1.实例化对象
      CreateThreadImplementsRunnable ce = new CreateThreadImplementsRunnable();

      //2.启动线程，不能直接调用start()方法; 因为Runnable接口里面没有start()方法
      Thread thread = new Thread(ce);
      //ce.run();
      thread.start();
      for (int i=0; i<20; i++){
          System.out.println("main i==="+i);
      }

  }
}

3. 使用匿名内部类的方式

/**
* 匿名内部类
*/
abstract class Animal{
   public abstract void animal();
}

public class CreateThreadAnimal {

   public static void main(String[] args){
       /*Animal animal = new Animal() {
           @Override
           public void animal() {
               System.out.println("调用匿名内部类");
           }
       };
       animal.animal();*/
       Thread thread = new Thread(new Runnable() {
           @Override
           public void run() {
               for (int i=0; i<20; i++){
                   System.out.println("run i==="+i);
               }
           }
       });
       //启动线程
       thread.start();
       for (int i=0; i<20; i++){
           System.out.println("main i==="+i);
       }

   }
}

4. callable接口
   后续学习

1.使用继承Thread类还是使用实现Runnable接口好？
使用实现实现Runnable接口好，原因实现了接口还可以继续继承，继承了类不能再继承。

2.启动线程是使用调用start方法还是run方法？
开始执行线程注意开启线程不是调用run方法，而是start方法
调用run只是使用实例调用方法。

5. 守护线程和非守护线程（用户线程）
   1.用户线程是主线程创建的和主线程互不干扰

public class ChildThread {

 public static void main(String[] arge){

     Thread thread = new Thread(new Runnable() {
         @Override
         public void run() {
             for(int i=0; i<20; i++){
                 System.out.println("子线程，i:"+i);
             }
         }
     });

     thread.start();
     System.out.println("主线程执行完毕。。。");
 }
}

效果如下图，主线程已执行完，子线程还在继续执行

2.守护线程 如 gc线程 跟随主线程一起被销毁

public class ChildThread {

 public static void main(String[] arge){

     Thread thread = new Thread(new Runnable() {
         @Override
         public void run() {
             for(int i=0; i<20; i++){
                 try {
                     Thread.sleep(300);
                 }catch (Exception e){

                 }
                 System.out.println("子线程，i:"+i);
             }
         }
     });

     //设置thread为守护线程
     thread.setDaemon(true);
     thread.start();
     for(int i=0; i<5; i++){
         try {
             Thread.sleep(300);
         }catch (Exception e){

         }
     }
     System.out.println("主线程执行完毕。。。");
 }
}

效果如下图，守护线程随主线程一起销毁

多线程运行状态

线程从创建、运行到结束总是处于下面五个状态之一：新建状态、就绪状态、运行状态、阻塞状态及死亡状态。
新建状态
当用new操作符创建一个线程时，例如new Thread®，线程还没有开始运行，此时线程处在新建状态。当一个线程处于新生状态时，程序还没有开始运行线程中的代码
就绪状态
一个新创建的线程并不自动开始运行，要执行线程，必须调用线程的start()方法。当线程对象调用start()方法即启动了线程，start()方法创建线程运行的系统资源，并调度线程运行run()方法。当start()方法返回后，线程就处于就绪状态。
处于就绪状态的线程并不一定立即运行run()方法，线程还必须同其他线程竞争CPU时间，只有获得CPU时间才可以运行线程。因为在单CPU的计算机系统中，不可能同时运行多个线程，一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。
运行状态
当线程获得CPU时间后，它才进入运行状态，真正开始执行run()方法.
阻塞状态
线程运行过程中，可能由于各种原因进入阻塞状态:
1>线程通过调用sleep方法进入睡眠状态；
2>线程调用一个在I/O上被阻塞的操作，即该操作在输入输出操作完成之前不会返回到它的调用者；
3>线程试图得到一个锁，而该锁正被其他线程持有；
4>线程在等待某个触发条件；

死亡状态
有两个原因会导致线程死亡：

1. run方法正常退出而自然死亡，
2. 一个未捕获的异常终止了run方法而使线程猝死。
   为了确定线程在当前是否存活着（就是要么是可运行的，要么是被阻塞了），需要使用isAlive方法。如果是可运行或被阻塞，这个方法返回true；如果线程仍旧是new状态且不是可运行的，或者线程死亡了，则返回false.

6. join()方法作用
   把当前线程的CPU执行权交个别个线程，当别个线程执行完后自己在执行
   相当于别个线程插队到当前线程前面

public class ThreadJoin {

 public static void main(String[] arge){

     Thread thread = new Thread(new Runnable() {
         @Override
         public void run() {
             for(int i=0; i<20; i++){
                 System.out.println("子线程，i:"+i);
             }
         }
     });
     thread.start();
     for(int i=0; i<20; i++){
         try {
             //将CPU执行权交给子线程
             thread.join();
         }catch (Exception e){

         }
         System.out.println("主线程执行完毕。。。");
     }
 }
}

效果如下图

join()面试题

1. 现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行

public class Thread3 {

 public static void main(String[] arge){

     Thread T1 = new Thread(new Runnable() {
         @Override
         public void run() {
             for(int i=0; i<20; i++){
                 System.out.println("T1，i:"+i);
             }
         }
     });
     T1.start();

     Thread T2 = new Thread(new Runnable() {
         @Override
         public void run() {
             //把Cpu执行权让给T1
             try {
                 T1.join();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             for(int i=0; i<20; i++){
                 System.out.println("T2，i:"+i);
             }
         }
     });
     T2.start();

     Thread T3 = new Thread(new Runnable() {
         @Override
         public void run() {
             //把Cpu执行权让给T2
             try {
                 T2.join();
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
             for(int i=0; i<20; i++){
                 System.out.println("T3，i:"+i);
             }
         }
     });
     T3.start();
 }
}