♥Java----多线程【超全总结附代码】

目录

​​

---

1、基本概念

2、线程创建的几种方式

3、线程的生命周期

4、线程的同步

5、线程的通信

​​1、基本概念 

程序

程序(program)是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。

进程

进程(process)是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期

如：运行中的QQ，运行中的MP3播放器

程序是静态的，进程是动态的

进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域

线程

进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一时间并行执行多个线程，就是支持多线程的

2、线程创建的几种方式

2.1、通过继承Thread类

先上代码，使用多线程打印0~100的整数

/**
 * 使用多线程打印0~100的偶数
 */

//首先继承Thread类
class Number1 extends Thread{
    //重写run()方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                //Thread.currentThread().getName()可以获取当前线程的名字
                System.out.println(Thread.currentThread().getName()+i);
            }
        }
    }
}
public class Thread_Test {
    public static void main(String[] args) {
        //创建Thread子类的对象
        Number1 num1 = new Number1();
        Number1 num2 = new Number1();
        Number1 num3 = new Number1();
        //修改线程的名字
        num1.setName("线程一：");
        num2.setName("线程二：");
        num3.setName("线程三：");
        //调用线程
        num1.start();
        num2.start();
        num3.start();
    }

}

总结：一共有四步①继承Thread类 ②重写run()方法 ③创建Thread的子类对象 ④ 通过对象.start()启动线程

2.2通过实现Runnable接口

好处：避免了单继承的局限性，多个线程可以共享同一个接口实现类的对象，非常适合多个相同线 程来处理同一份资源。

//①实现Runnable接口
class number2 implements Runnable {
    //②实现run()方法
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + i);
            }
        }
    }
}

public class Runnable_Test {
    public static void main(String[] args) {
        //③实例化number2的对象
        number2 num = new number2();
        //④把对象作为参数传递给Thread的构造器
        Thread b1 = new Thread(num);
        Thread b2 = new Thread(num);
        Thread b3 = new Thread(num);
        
        b1.setName("线程一：");
        b2.setName("线程二：");
        b3.setName("线程三：");
        //⑤调用start方法
        b1.start();
        b2.start();
        b3.start();
    }
}

总结：一共有五步①实现Runnable接口②实现run()方法③造对象④把对象作为参数传递给构造器⑤调用start方法

2.3通过实现Callable接口

特点：与使用Runnable相比， Callable功能更强大些，

• 相比run()方法，可以有返回值 
• 方法可以抛出异常 
• 支持泛型的返回值 
• 需要借助FutureTask类，比如获取返回结果

  import java.util.concurrent.Callable;
  import java.util.concurrent.ExecutionException;
  import java.util.concurrent.FutureTask;
  
  /**
   * 打印偶数，并返回这些偶数的总和
   */
  //实现Callable接口
  class number3 implements Callable{
      //重写call()方法
  
      @Override
      public Object call() throws Exception {
          int sum=0;
          for (int i = 0; i < 100; i++) {
              if(i%2==0){
                  System.out.println(i);
                  sum+=i;
              }
          }
          return sum;
      }
  }
  
  public class Callable_Test {
      public static void main(String[] args) {
          //创建Callable接口实现类的对象
          number3 num = new number3();
          //把对象扔进FutureTask的构造器中作为参数
          FutureTask futureTask1 = new FutureTask(num);
          //将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
          new Thread(futureTask1).start();
          try {
              //通过get()方法获取返回值
              Object obj = futureTask1.get();
              //打印返回值
              System.out.println(obj.toString());
          } catch (InterruptedException e) {
              e.printStackTrace();
          } catch (ExecutionException e) {
              e.printStackTrace();
          }
  
      }
  }

  2.4线程池

特点

• 提高相应速度
• 降低资源消耗
• 便于线程管理

  class NumberThread implements Runnable{
  
      @Override
      public void run() {
          for(int i = 0;i <= 100;i++){
              if(i % 2 == 0){
                  System.out.println(Thread.currentThread().getName() + ": " + i);
              }
          }
      }
  }
  
  class NumberThread1 implements Runnable{
  
      @Override
      public void run() {
          for(int i = 0;i <= 100;i++){
              if(i % 2 != 0){
                  System.out.println(Thread.currentThread().getName() + ": " + i);
              }
          }
      }
  }
  
  public class ThreadPool {
  
      public static void main(String[] args) {
          //1. 提供指定线程数量的线程池
          ExecutorService service = Executors.newFixedThreadPool(10);
          ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
  
  
          //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
          service.execute(new NumberThread());//适合适用于Runnable
          service.execute(new NumberThread1());//适合适用于Runnable
  
          //3.关闭连接池
          service.shutdown();
      }
  
  }
  

  后续更新······