多线程

多线程

之前学的多线程也总结一下。感兴趣的小伙伴可以看看哦！

一、线程与进程

1. 进程：在操作系统上每个运行的应用程序实例
2. 进程的特点：宏观并行，微观串行
3. 线程：操作系统可以调度的最小单位，包含于进程之中，是进程的实际运行单位
4. 线程的组成：CPU分配的时间片、数据空间(堆栈空间)、运行的代码
   1. CPU分配的时间片：由操作系统(OS)决定
   2. 数据空间：堆空间由所有线程共享，栈空间每个线程独有
   3. 运行的代码：每个线程执行的任务

二、线程的创建方式

1. 实现Runnable接口，实现其中的run()方法

   package com.baizhi.testThread;
   
   public class TestThread {
   	public static void main(String[] args) {
   //		创建任务对象
   		Task task = new Task();
   //		创建线程对象，将任务传递给线程
   		Thread t = new Thread(task);
   //		开启线程
   		t.start();
   	}
   }
   class Task implements Runnable{
   	@Override
   	public void run() {
   		System.out.println("线程创建");
   	}
   }
   

   **注意：**开启线程的方式是调用线程对象的start()方式，而不是直接调用其run()方法

2. 继承Thread类，覆盖其中的run()方法

   package com.baizhi.testThread;
   
   public class TestThread {
   	public static void main(String[] args) {
   //		创建任务对象
   		Task task = new Task();
   //		创建线程对象，将任务传递给线程
   		Thread t = new Thread(task);
   //		开启线程
   		t.start();
   	}
   }
   class Task extends Thread{
   	@Override
   	public void run() {
   		System.out.println("线程创建");
   	}
   }
   

   **注意：**开启线程的方式是调用线程对象的start()方式，而不是直接调用其run()方法

三、线程的状态

1. new：初始状态：线程对象被创建，存储在堆内存中，此时的线程对象与一般的Java对象没有差异

2. runnable：可运行状态：分为准备就绪和运行中

   1. ready：就绪状态：当线程对象调用start方法之后，线程进入就绪状态，等待操作系统分配时间片
   2. running：运行状态：当就绪状态的线程对象获取时间片之后，线程进入运行状态，执行run方法中的代码，当线程失去时间片的时候，该线程回到ready状态

3. terminated：终止状态：线程任务结束之后，进入该状态，并且立即释放时间片

4. timed_waiting：计时等待状态：当线程对象调用sleep方法之后，线程会根据传入的参数时间进入计时等待状态，该状态下的线程会释放时间片

   package com.baizhi.testThread;
   
   public class TestSleep {
   	public static void main(String[] args) {
   //		使用Thread类中的静态方法使线程进入计时等待状态
   		try {
   			Thread.sleep(100);
   		} catch (InterruptedException e) {
   			e.printStackTrace();
   		}
   	}
   }
   

5. waiting：不计时等待状态：当某个线程调用join方法之后，当前线程会等待该线程进入终止状态之后再继续向下运行

   package com.baizhi.testThread;
   
   public class TestJoin {
   	public static void main(String[] args) throws Exception{
   //		创建一个线程
   		Thread t1 = new Thread(()-> System.out.println("Thread t1"));
   //		当前线程(main)无计时等待t1线程
   		t1.join();
   //		t1线程进入终止状态之后，当前线程继续运行
   		System.out.println("main end");
   	}
   }
   

四、线程池

1. 线程池的概念：线程池是一个容器，线程对象将预先创建并存入其中，这些线程可以重复使用
2. 线程池的好处：使用线程减少线程的创建和销毁次数，节省资源
3. 线程池的接口和类：
   1. Executor：线程池的根接口
   2. ExecutorService：Executor的子接口，定义了submit(Runnable r)方法，用于提交任务
   3. Executors：Executor接口的工具类，可以通过该类的静态方法获取线程池
4. 线程池的创建：
   1. Executors.newFixedThreadPool(int n):创建一个内部存有n个线程的线程池，是定量线程池
   2. Executors.newCachedThreadPool():创建一个不定量的线程池
5. 线程池的引用类型：使用子接口ExecutorService，而不是根接口Executor
6. 任务的提交：使用线程池对象的submit(Runnable r)方法，参数传入一个任务对象
7. 线程池的关闭：使用线程池的shutdown()方法

package com.baizhi.testThread;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class TestThreadPool {
	public static void main(String[] args) {
//		创建任务对象
		Runnable t1 = () -> System.out.println("t1");
		Runnable t2 = () -> System.out.println("t2");
		Runnable t3 = () -> System.out.println("t3");
//		创建线程池
//		ExecutorService pool = Executors.newFixedThreadPool(2);
		ExecutorService pool = Executors.newCachedThreadPool();
//		向线程池提交任务
		pool.submit(t1);
		pool.submit(t2);
		pool.submit(t3);
//		关闭线程池
		pool.shutdown();
	}
}

五、Callable接口和Future接口

1. Callable接口：JDK1.5版本，可以有返回值，可以抛出异常