Java入门-线程概述

今日语录：明白自己所做的一切是为了什么，不论结果是好是坏

一、线程和进程的基本概念

进程

1、进程指运行中的程序，比如我们使用的QQ，就启动了一个进程，操作系统就会为该进程分配内存空间，当我们使用了迅雷，又会启动一个进程，操作系统将为迅雷分配新的内存空间。

2、进程是程序的一次执行过程，或是正在运行的一个程序。是动态的过程：有它自身的产生、存在和消亡的过程

线程

什么是线程

1、线程由进程创建的，是进程的一个实体

2、一个进程可以拥有多个线程

其他相关概念

1、单线程：同一时刻，只允许执行一个线程

2、多线程：同一时刻，可以执行多个线程，比如：一个QQ进程，可以同时打开多个聊天窗口，一个迅雷进程，可以同时下载多个文件

3、并发：同一时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单来说，单核CPU实现的多任务就是并发

4、并行：同一时刻，多个任务同时执行。多核CPU可以实现并行

二、线程基本使用

• 创建线程的两种的方式

  1、继承Thread类，重写run方法

  2、实现Runnable接口，重写run方法

3、示例代码

package Thread;

/**
 * @author chenx
 * @date 2022年03月06日
 */
public class Demo01 {
 public static void main(String[] args) {
  Cat cat = new Cat();
  cat.start();
 }
}

class Cat extends Thread{
 int times = 0;
 @Override
 public void run(){
  while(true){
   System.out.println("喵喵喵"+(++times));
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   if(times == 8) break;
  }
 }

}

使用JConsole监控线程执行情况

当主线程运行结束，子线程并不会随着消失

三、为什么使用start()启动线程而不是调用run()？

• run()方法就是一个普通的方法，没有真正的启动线程，就会把run方法执行完毕，才向下执行（串行化执行）

• start方法调用start0()方法后，该线程并不一定会马上执行，只是将线程变成了可运行状态，具体什么时候执行，取决于CPU，由CPU统一调度。

  

• 真正实现多线程的效果，是start0()，而不是run()，看start()源码

  

四、线程基本使用

实现Runnabel接口（底层采用：静态代理模式）

2、java设计者们提供了另外一个方式创建线程，就是通过实现Runnable接口来创建线程。

示例代码

package Thread;

/**
 * @author chenx
 * @date 2022年03月06日
 */
public class Demo01 {
 public static void main(String[] args) throws InterruptedException {
  Dog dog = new Dog();
  Thread thread = new Thread(dog);
  thread.start();

  System.out.println("主线程继续执行："+Thread.currentThread().getName());
  for(int i=0;i<50;i++){
   System.out.println("主线程i="+i);
   Thread.sleep(1000);
  }

 }

}

class Dog implements Runnable{

 @Override
 public void run(){
  int times = 0;
  while(true){
   System.out.println("汪汪汪"+(++times) + Thread.currentThread().getName());
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   if(times == 100) break;
  }
 }

}

五、静态代理模式

示例代码

package Thread;

/**
 * @author chenx
 * @date 2022年03月06日
 */
public class Demo01 {
 public static void main(String[] args) throws InterruptedException {
  //Dog dog = new Dog();
  //Thread thread = new Thread(dog);
  //thread.start();
  //
  //System.out.println("主线程继续执行："+Thread.currentThread().getName());
  //for(int i=0;i<50;i++){
  // System.out.println("主线程i="+i);
  // Thread.sleep(1000);
  //}
  Tiger t = new Tiger();
  ThreadProxy threadProxy = new ThreadProxy(t);
  threadProxy.start();
 }

}

class Dog implements Runnable{

 @Override
 public void run(){
  int times = 0;
  while(true){
   System.out.println("汪汪汪"+(++times) + Thread.currentThread().getName());
   try {
    Thread.sleep(1000);
   } catch (InterruptedException e) {
    e.printStackTrace();
   }
   if(times == 100) break;
  }
 }

}

class Animal{}

class Tiger extends Animal implements Runnable{

 @Override
 public void run() {
  System.out.println("老虎不是猫");
 }
}

// 线程代理类，模拟了一个极简的Thread类
class ThreadProxy implements Runnable{

 private Runnable target = null;

 @Override
 public void run(){
  if(target != null){
   target.run();
  }
 }

 public ThreadProxy(Runnable target){
  this.target = target;
 }
 public void start(){
  start0();
 }
 public void start0(){
  run();
 }

}

六、多线程执行案例

要求：请编写一个程序，创建两个线程，一个线程每秒输出“hello,world”，输出10次，退出，一个线程每秒输出“hi”，输出5次退出。使用实现Runnable接口的方式

package Thread;

/**
 * @author chenx
 * @date 2022年03月12日
 */
public class ThreadDemo {
 public static void main(String[] args) {

  T2 t2 = new T2();
  T3 t3 = new T3();
  Thread thread1 = new Thread(t2);
  Thread thread2 = new Thread(t3);
  thread1.start();
  thread2.start();

 }
}

class T3 implements Runnable{
  int count = 0;

  @Override
 public void run(){
  while(true){
   System.out.println("hello,world "+(++count));
   try{
    Thread.sleep(1000);
   }catch(InterruptedException e ){
    e.printStackTrace();
   }
   if(count == 10) break;
  }
  }
}
class T2 implements Runnable{
 int count = 0;

 @Override
 public void run(){
  while(true){
   System.out.println("Hi "+(++count));
   try{
    Thread.sleep(1000);
   }catch(InterruptedException e ){
    e.printStackTrace();
   }
   if(count == 5) break;
  }
 }
}

七、继承Thread VS 实现Runnable的区别

• 1、从Java的设计来说，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就是实现了Runnable接口
• 2、实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制，建议使用Runnable接口

售票系统

package Thread;

/**
 * @author chenx
 * @date 2022年03月12日
 */
public class SaleTickets{

 public static void main(String[] args) {
  //SellTicket01 sellTicket01 = new SellTicket01();
  //SellTicket01 sellTicket02 = new SellTicket01();
  //SellTicket01 sellTicket03 = new SellTicket01();
  //sellTicket01.start();
  //sellTicket02.start();
  //sellTicket03.start();
  //

  SellTicket02 sellTicket02 = new SellTicket02();
  new Thread(sellTicket02).start();
  new Thread(sellTicket02).start();
  new Thread(sellTicket02).start();
  //SellTicket02 sellTicket02 = new SellTicket02();
  //SellTicket02 sellTicket03 = new SellTicket02();
  //Thread thread1 = new Thread(sellTicket01);
  //Thread thread2 = new Thread(sellTicket02);
  //Thread thread3 = new Thread(sellTicket03);
  //thread1.start();
  //thread2.start();
  //thread3.start();

 }

}


class SellTicket01 extends Thread{

 //让多线程共享资源 ticketNum
 private static int ticketNum = 100;

 @Override
 public void run(){
  while(true){
   if(ticketNum <= 0){
    System.out.println("售票结束...");
    break;
   }
   //休眠50毫秒
   try{
    Thread.sleep(50);
   }catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("窗口： "+Thread.currentThread().getName()+" 售出一张票，"+"剩余票数="+(--ticketNum));
  }
 }
}

class SellTicket02 implements Runnable{

 //让多线程共享资源 ticketNum
 private static int ticketNum = 100;

 @Override
 public void run(){
  while(true){
   if(ticketNum <= 0){
    System.out.println("售票结束...");
    break;
   }
   //休眠50毫秒
   try{
    Thread.sleep(1);
   }catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("窗口： "+Thread.currentThread().getName()+" 售出一张票，"+"剩余票数="+(--ticketNum));
  }
 }
}

八、线程终止

基本说明

1、当线程完成任务后，会自动退出

package Thread;

/**
 * @author chenx
 * @date 2022年03月12日
 */
public class SaleTickets{

 public static void main(String[] args) throws InterruptedException {
  
  SellTicket02 sellTicket02 = new SellTicket02();
  new Thread(sellTicket02).start();
  new Thread(sellTicket02).start();
  new Thread(sellTicket02).start();

  Thread.sleep(2*10);
  sellTicket02.setLoop(false);
  

 }

}
class SellTicket02 implements Runnable{

 //让多线程共享资源 ticketNum
 private static int ticketNum = 1000;

 private boolean loop = true;

 @Override
 public void run(){
  while(loop){
   if(ticketNum <= 0){
    System.out.println("售票结束...");
    break;
   }
   //休眠50毫秒
   try{
    Thread.sleep(1);
   }catch (InterruptedException e) {
    e.printStackTrace();
   }
   System.out.println("窗口： "+Thread.currentThread().getName()+" 售出一张票，"+"剩余票数="+(--ticketNum));
  }
 }

 public void setLoop(boolean loop){
  this.loop = loop;
 }

}

九、线程常用方法

• 常用方法第一组

  1、setName: 设置线程名称，使之与参数name相同

                          2、getName：返回该线程的名称                                                             

  3、start：使该线程开始执行，Java虚拟机底层调用该线程的start0()方法

                                                                                                      4、run：调用线程对象run方法                                                              

  5、setPriority:更改线程的优先级

                                                             6、getPriority:获取线程的优先级

                                                          7、sleep:在指定的毫秒数内让当前正在执行的线程休眠（暂停执行）

                                                                                                                     8、Interrupt: 中断线程

注意事项和细节

• 1、start()底层会创建新的线程，调用run,run就是一个简单的方法调用，不会启用新线程

  
  

• 2、线程优先级的范围

  
  

• 3、interrupt:中断线程，但并没有真正结束线程，所以一般处于中断线程正在休眠线程

  
  

• 4、sleep:线程的静态方法，使当前线程休眠

  
  

• 常用方法第二组

  1、yield:线程的礼让，让出CPU，让其他线程执行，但礼让的时间又不一定，所以也不一定礼让成功                                                        

  2、join:线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务

  案例：创建一个子线程，每隔一个1s输出hello,输出20次，主线程每隔1秒，输出hi输出20次，两个线程同时执行，当线程输出5次后，就让子线程运行完毕，主线程再继续。

  package Thread;
  
  /**
   * @author chenx
   * @date 2022年03月13日
   */
  public class ThreadDemo2 {
   public static void main(String[] args) throws InterruptedException {
    Th2 t2 = new Th2();
    t2.start();
  
    for(int i=0;i<=20;i++){
     Thread.sleep(1000);
     System.out.println("大哥，hi");
     if(i==2){
      System.out.println("大哥线程礼让，小弟线程后续运行-------------");
      Thread.yield();
     }
     if(i==5){
      System.out.println("让大哥线程先进行，小弟线程后续运行-------------");
      t2.join();
     }
  
    }
  
   }
  }
  
  class Th2 extends Thread{
  
   @Override
   public void run(){
    for(int i=0;i<=20;i++){
     try{
      Thread.sleep(1000);
     }catch (InterruptedException e){
      e.printStackTrace();
     }
     System.out.println("小弟，Hello");
    }
   }
  }
  

  

十、用户线程和守护线程

1、用户线程：也叫工作线程，当线程的任务执行完成或通知方式结束

2、守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束

3、常见的守护线程：垃圾回收机制

package Thread;

/**
 * @author chenx
 * @date 2022年03月13日
 */
public class ThreadDemo2 {
 public static void main(String[] args) throws InterruptedException {
  Th2 t2 = new Th2();
  t2.setDaemon(true);
  t2.start();

  for(int i=0;i<=20;i++){
   Thread.sleep(1000);
   System.out.println("大哥，hi:"+i);
  }

 }
}

class Th2 extends Thread{

 @Override
 public void run(){
  for(int i=0;i<=50;i++){
   try{
    Thread.sleep(1000);
   }catch (InterruptedException e){
    e.printStackTrace();
   }
   System.out.println("小弟，Hello:"+i);
  }
 }
}

十一、线程的生命周期

• JDK中用Thread.State枚举表示了线程的几种状态

   1、NEW

  尚未启动的线程处于此状态                                                 

  2、RUNNABLE

  在Java虚拟机中执行的线程处于此状态               

     3、BLOCKED

  被阻塞等待监视器锁定的线程处于此状态

                 4、WAITING

  正在等待另一个线程执行特定动作的线程处于此状态

                                                                                                                             5、TIMED_WAITING

  正在等待另一个线程执行动作达到指定等待时间的线程处于此状态                                                                            

     6、TERMINATED

  已退出的线程处于此状态

  

  线程状态转换图：

  

十二、线程同步机制-Synchronized

• 线程同步机制

  1、在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任意时刻，最多有一个线程访问，以保证数据的完整性                                                                        

    2、也可以这么理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。

• Synchronized

  1、同步代码块

  synchronized (对象){ // 得到对象的锁，才能操作同步代码
  	// 需要被同步代码
  }
  

  2、synchronized还可以放在方法声明中，表示整个方法-为同步方法

  public synchronized void m(String name){
  	// 需要被同步的代码
  }
  

• 使用同步机制解决售票系统问题

  package Thread;
  
  /**
   * @author chenx
   * @date 2022年03月12日
   */
  public class SaleTickets{
  
   public static void main(String[] args) throws InterruptedException {
  
  
    SellTicket02 sellTicket02 = new SellTicket02();
    new Thread(sellTicket02).start(); // 窗口1
    new Thread(sellTicket02).start(); // 窗口2
    new Thread(sellTicket02).start(); // 窗口3
    new Thread(sellTicket02).start(); // 窗口4
    new Thread(sellTicket02).start(); // 窗口5
  
    Thread t = new Thread(sellTicket02);
    t.setName("Test线程");
    t.start();
   }
  
  }
  
  
  class SellTicket01 extends Thread{
  
   //让多线程共享资源 ticketNum
   private static int ticketNum = 100;
  
   @Override
   public void run(){
    while(true){
     if(ticketNum <= 0){
      System.out.println("售票结束...");
      break;
     }
     //休眠50毫秒
     try{
      Thread.sleep(50);
     }catch (InterruptedException e) {
      e.printStackTrace();
     }
     System.out.println("窗口： "+Thread.currentThread().getName()+" 售出一张票，"+"剩余票数="+(--ticketNum));
    }
   }
  }
  
  class SellTicket02 implements Runnable{
  
   //让多线程共享资源 ticketNum
   private static int ticketNum = 1000;
  
   private boolean loop = true;
  
   public synchronized void sell(){
    if(ticketNum <= 0){
     System.out.println("售票结束...");
     loop = false;
     return;
    }
    //休眠50毫秒
    try{
     Thread.sleep(50);
    }catch (InterruptedException e) {
     e.printStackTrace();
    }
    System.out.println("窗口： "+Thread.currentThread().getName()+" 售出一张票，"+"剩余票数="+(--ticketNum));
   }
  
   @Override
   public void run(){
    while(loop){
     sell();
    }
   }
  
   public void setLoop(boolean loop){
    this.loop = loop;
   }
  
  }
  

  

十三、互斥锁

• 基本介绍

  1、Java在java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性

  
  

  
  

  2、每个对象都对应于一个可称为”互斥锁“的标记，这个标记用来保证在任意时刻，只能有一个线程访问该对象                                                                                                                          3、关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任意时刻只能由一个线程访问

  
  

  
  

  4、同步的局限性：导致线程的执行效率降低                                                                                                                          

  5、同步方法（非静态的）的锁可以是this，也可以是其他对象（要求是一个对象）                                                                                    

  6、同步方法（静态的）的锁为当前类本身

• 注意事项和细节

   1、同步方法如果没有使用static修饰，默认锁对象为this             

  2、如果方法使用static修饰，默认锁对象为：当前类.class

           3、实现的落地步骤：

• 需要先分析上锁的代码
• 选择同步代码块或同步方法
• 要求多个线程的锁对象为同一个即可

十四、线程的死锁

• 基本介绍

  1、多线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生。

十五、释放锁

下面的操作会释放锁

下面操作不会释放锁