一、基本概念
1.1、程序、进程、线程
程序（program）：是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程（process）：正在运行中的程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
线程（thread）：进程可以进一步细化为线程，是一个程序内部的一条执行路径。
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈核程序计数器（pc），线程切换的开销小
1.2、单核CPU和多核CPU
单核CPU：其实是一种假的多线程，因为 在一个时间单元内，也只能执行一个线程的任务。但是因为CPU时间单元特别短，因此感觉不出来。
多核CPU：可以更好地发挥多线程的效率。
另外，**一个Java应用程序java.exe，其实至少有三个线程：mian()主线程，gc()垃圾回收线程，异常处理线程。**当然如果发生异常，会影响主线程。
1.3、并行与并发
并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事情。
并发：一个CPU（采用时间片的策略）同时执行多个任务。比如：618、双11的秒杀活动；多个人做同一件事。
1.4、多线程的优点
- 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
- 提高计算机系统CPU的利用率
- 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。
1.5、何时用多线程
- 程序需要同时执行两个或多个任务
- 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等
- 需要一些后台运行的程序时。
二、线程的创建和使用
2.1、创建线程方式一–继承Thread类
四步：
1.创建一个继承于 Thread类的子类
2.重写Thread类的run() --> 将此线程执行的操作声明在run()中
3.创建Thread类的子类的对象
4.通过此对象调用start() --> ① 启动当前线程 ② 调用当前线程的run()
举个例子：
方式一
public class ThreadDemo {
public static void main(String[] args) {
MyThread1 thread1 = new Mythread1();
thread1.start();
Mythread2 thread2 = new Mythread2();
thread2.start();
}
}
// 方法一
class Mythread1 extends Thread{
@Override
public void run() {
//遍历100以内的奇数
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName() + ":"+i);
}
}
}
}
class Mythread2 extends Thread{
@Override
public void run() {
//遍历100以内的偶数
for (int i=0;i<100;i++){
if (!(i%2==0)){
System.out.println(Thread.currentThread().getName() + ":"+i);
}
}
}
}
方式二：使用thread类的匿名子类
public class threadDemo {
public static void main(String[] args) {
//方法二
//创建thread类的匿名子类的方式
new Thread(){
public void run() {
//遍历100以内的偶数
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName() + ":"+i);
}
}
}
}.start();
new Thread(){
public void run() {
//遍历100以内的奇数
for (int i=0;i<100;i++){
if (!(i%2==0)){
System.out.println(Thread.currentThread().getName() + ":"+i);
}
}
}
}.start();
}
}
2.2、创建线程方式二–实现Runnable接口
创建多线程的方式二：实现Runnable接口
五步
1.创建一个实现了Runnable接口的类
2.实现类去实现实现Runnable中的抽象方法：run()
3.创建实现类的对象
4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5.通过Thread类的对象调用start()
举例：
//1.创建一个实现了Runnable接口的类
class MThread implements Runnable{
//2.实现类去实现实现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 ThreadTest1 {
public static void main(String[] args) {
//3.创建实现类的对象
MThread m1 = new MThread();
//4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
Thread t1 = new Thread(m1);
t1.setName("线程1");
//5.通过Thread类的对象调用start():
t1.start();
//再创建一个线程，遍历100以内的偶数
Thread t2 = new Thread(m1);
t2.setName("线程2");
t2.start();
}
}
2.3、两种方法比较
比较创建线程的两种方式。
开发中：优先选择：实现Runnable接口的方式
原因
- 实现的方式没有类的单继承性的局限性
- 实现的方式更适合来处理多个线程有共享数据的情况。
联系：public class Thread implements Runnable
相同点：两种方式都需要重写run()，将线程要执行的逻辑声明在run()中。
2.2、重命名线程
2.2.1、方式一–setName()
HelloThread h1 = new HelloThread();
h1.setName("线程一");
h1.start();
2.2.2、方式二–构造器
class HelloThread extends Thread{
@Override
public void run() {
for (int i=0;i<100;i++){
if (i%2==0){
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
//通过构造器的方式给线程命名
public HelloThread(String name){
super(name);
}
}
public static void main(String[] args) {
HelloThread h1 = new HelloThread("Thread: 1");
h1.start();
}
}
2.3、常用方法
1.start(): 启动当前线程；调用当前线程的run()
2.run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中
3.currentThread(): 静态方法，返回执行档期那代码的线程
4.getName(): 获取当前线程的名字
System.out.println(Thread.currentThread().getName());
5.setName(): 设置当前线程的名字
h1.setName("线程一");
//给主线程命名
Thread.currentThread().setName("主线程");
6.yield(): 释放当前cpu的执行权
if (i%20==0){
this.yield();
}
7.join(): 在线程a中调用线程b的join()，此时线程a就进入阻塞状态，直到线程b执行完后，线程a才结束阻塞状态
if (i == 20){
try {
h1.join();
}catch (InterruptedException e){
e.printStackTrace();
}
}
8.stop(): 已过时。当执行此方法时，强制结束当前线程
9.sleep(long millitime): 让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
//单位是 毫秒，如果睡1秒，就要写1000
sleep(1000);
10.isAlive(): 判断当前线程是否存活
System.out.println(h1.isAlive());
2.4、线程的优先级
MAX_PRIORITY = 10
MIN_PRIORITY = 1
NORM_PRIORITY = 5
2.如何获取和设置当前线程的优先级：
-
getPriority()：获取线程的优先级 setPriority(int p)：设置线程的优先级
说明：高优先级的线程要抢占低优先级的cpu的执行权。但是只是从概率山讲，高优先级的线程高概率的情况下被执行。并不意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
三、线程的生命周期
四、线程的同步
4.1、解决线程安全方式一–同步代码块
例子：创建三个窗口卖票，总票数为100张。使用实现Runnable接口的方式
* 1.问题:卖票过程中，出现了重票、错票-->出现了线程的安全问题
* 2.问题出现的原因:当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
* 3.如何解决: 当一个线程a在操作ticket的时候，其他线程不能参与进来。
* 直到线程a操作完ticket时，其他线程才可以开始操作ticket.
* 这种情况即使贤臣和a出现了阻塞，也不能被改变。
*4.在Java中，我们通过同步机制，来解决线程的安全问题
* 方式一：同步代码块
* synchronized(同步监视器){
* //需要被同步的代码
* }
* 说明:
* 1.操作共享数据的代码，即为需要被同步的代码
* 2.共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。
* 3.同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。
* 要求:多个线程必须要共用同一把锁。
* 补充：在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器；
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
*
* 方式二:同步方法
* 关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2.非静态的同步方法，同步监视器是 this
静态的同步方法，同步监视器是：当前类本身 如：Window2.class
* 5.同步的方式，解决了线程的安全问题。---好处
* 操作同步代码时，只能有一个线程参与，其他线程等待，相当于是一个单线程的过程，效率低。---局限性
4.2、解决线程安全方式二–同步方法
关于同步方法的总结：
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明
2.非静态的同步方法，同步监视器是 this
静态的同步方法，同步监视器是：当前类本身 如：Window2.class
4.3、线程安全的懒汉式单例模式
/**
* 将懒汉式的单例模式改为线程安全的
*/
class Bank{
//1.私有化类的构造器
private Bank(){
}
//2.声明当前对象，没有初始化
//4.要求此对象也必须是static的
private static Bank instance = null;
//3.声明 public、static的返回当前类对象的方法
public static Bank getInstance(){
//方式一：效率稍差
// synchronized (Bank.class){
// if (instance ==null){
// instance = new Bank();//实例化一下
// }
// return instance;
// }
//方式二: 效率更高
if (instance == null){
synchronized (Bank.class){
if (instance == null){
instance = new Bank();
}
}
}
return instance;
}
}
4.4、死锁
死锁 ：不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃 自己需要的同步资源，就形成了线程的死锁
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于 阻塞状态，无法继续
解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
演示死锁的过程
package 20230424;
/**
* @author: Arbicoral
* @create: 2023-04-24 10:44
* @Description: 演示线程的死锁问题
*/
public class ThreadTest {
public static void main(String[] args) {
//常用类，一个特别的字符串
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread(){
//使用Thread的匿名子类的方式创建多线程
@Override
public void run() {
synchronized (s1){
s1.append("a");
s2.append("1");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized(s2){
s1.append("b");
s2.append("2");
System.out.println(s1);
System.out.println(s2);
}
}
}
}.start();
new Thread(new Runnable() {
@Override
public void run() {
synchronized (s2){
s1.append("c");
s2.append("3");
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized(s1){
s1.append("d");
s2.append("4");
System.out.println(s1);
System.out.println(s2);
}
}
}
}).start();
}
}
4.5、解决线程安全方式三–ReentrantLock锁
解决线程安全问题的方式三：Lock锁 ---JDK5.0新增
步骤：
1.实例化ReentrantLock
2.调用锁定方法lock() -- 相当于同步监视器
3.调用解锁的方法 unlock()
举例：
package cs20230424;
class Window implements Runnable{
private int ticket = 100;
//1.实例化ReentrantLock
private ReentrantLock lock = new ReentrantLock();//true:公平的Lock，先进先出
@Override
public void run() {
while (true){
try {
//2.调用锁定方法lock() -- 相当于同步监视器
lock.lock();
if (ticket > 0){
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName()+"售票，票号为"+ticket);
ticket--;
}else {
break;
}
}finally {
//3.调用解锁的方法 unlock()
lock.unlock();
}
}
}
}
经典面试题：synchronzied 和 Lock的异同？
相同点：都是为了解决线程安全问题
不同点：
① Lock需要手动的启动同步(lock())，同时结束同步也需要手动的实现(unlock())
② synchronzied 机制在执行完相应的同步代码后，自动的释放同步监视器
优先使用顺序：
Lock -->同步代码块（已经进入了方法体，分配了相应资源） --> 同步方法 （在方法体之外）
4.6、线程的通信
线程通信的例子
package 20230424;
/**
* @author: Arbicoral
* @create: 2023-04-24 15:46
* @Description: 线程通信的例子:使用两个线程打印1-100。线程1，线程2 交替打印
* 涉及到的三个方法:
* wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
* notify():一旦执行此方法，就会唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的线程
* notifyAll():一旦执行此方法，就会唤醒被wait的所有线程。
*
*
* 说明：
* 1.wait(), notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中
* 2.wait(), notify(),notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器
* 否则会报 IllegalMonitorStateException 异常
* 3.wait(), notify(),notifyAll()三个方法是定义在java.Object类中的
*/
class Number implements Runnable{
private int num = 1;//共享数据
Object object = new Object();
@Override
public void run() {
while (true){
synchronized (object){
//同步代码块
this.notify();//唤醒进程
// notifyAll();//唤醒所有的进程
if (num <=100){
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName()+":"+num);
num++;
try {
//使得调用如下wait()方法的线程进入阻塞状态
wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}else {
break;
}
}
}
}
}
public class CommunicationTest {
public static void main(String[] args) {
Number number = new Number();
Thread t1 = new Thread(number);
Thread t2 = new Thread(number);
t1.setName("线程1");
t2.setName("线程2");
t1.start();
t2.start();
}
}
经典面试题：sleep()和wait()的异同？
1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
2.不同点：
- 两个方法声明的位置不同：Thread类中声明 sleep()，Object类中声明 wait()
- 调用的范围不同：sleep() 可以在任何需要的场景下调用。wait() 必须使用在同步代码块中
- 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁（同步监视器）
五、JDK5.0新增线程创建方式
5.1、创建线程的方式三–实现Callable接口
-----属于JKD5.0新增
与使用Runnable相比， Callable功能更强大些
- 相比run()方法，call()可以有返回值
- call()方法可以抛出异常 ，被外面的操作捕获，获取异常的信息
- Callable支持泛型的返回值
- 需要借助FutureTask类，比如获取返回结果
创建线程的方式三--实现Callable接口的步骤：
1.创建一个实现Callable的实现类
2.实现call方法，将此线程需要执行的操作声明在call()中
3.创建Callable接口实现类的对象
4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
6.获取Callable中call方法的返回值
```java
package 20230424;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @author: Arbicoral
* @create: 2023-04-24 18:16
* @Description: 创建线程的方式三--实现Callable接口 -----属于JKD5.0新增
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable{
//2.实现call方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
//相当于run()
//遍历100以内的偶数，并返回sum
int sum=0;
for (int i=1;i<=100;i++){
if (i%2==0){
System.out.println(i);
sum += i;
}
}
return sum;//sum是基本数据类型，这里包含多态，将int转为integer,再赋给Object
}
}
public class ThreadNew {
public static void main(String[] args) {
//3.创建Callable接口实现类的对象
NumThread thread = new NumThread();
//4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(thread);
//5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
//6.获取Callable中call方法的返回值
//get()的返回值即为Future构造器参数Callable实现类重写的call()的返回值
Object sum = futureTask.get();
System.out.println("总和为："+sum);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
}
}
5.2、创建线程的方式四–使用线程池
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程， 对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完 放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交 通工具。
好处：
- 提高响应速度（减少了创建新线程的时间）
- 降低资源消耗（重复利用线程池中线程，不需要每次都创建）
- 便于线程管理
corePoolSize：核心池的大小maximumPoolSize：最大线程数keepAliveTime：线程没有任务时最多保持多长时间后会终止
使用线程池创建线程的步骤：
1.提供指定线程数量的线程池
2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类
3.关闭连接池 service.shutdown()
举个例子
package 20230424;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* @author: Arbicoral
* @create: 2023-04-24 18:41
* @Description: 创建线程的方式四：使用线程池
*/
class NumberThread implements Runnable{
@Override
public void run() {
for (int i=1;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=1;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;
service1.setCorePoolSize(15);
// service1.setMaximumPoolSize();
//2.执行指定的线程的操作，需要提供实现Runnable接口或Callable接口实现类
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());//适合适用于Runnable
// service.submit(Callable callable);//适合使用于Callable
//3.关闭连接池
service.shutdown();
}
}
5.3、线程池相关API
JDK 5.0起提供了线程池相关API：ExecutorService 和 Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command) ：执行任务/命令，没有返回值，一般用来执行 Runnable
- Future submit(Callable task)：执行任务，有返回值，一般又来执行 Callable
- void shutdown() ：关闭连接池
Executors：工具类、线程池的工厂类，用于创建并返回不同类型的线程池
- Executors.newCachedThreadPool()：创建一个可根据需要创建新线程的线程池
- Executors.newFixedThreadPool(n); 创建一个可重用固定线程数的线程池
- Executors.newSingleThreadExecutor() ：创建一个只有一个线程的线程池
- Executors.newScheduledThreadPool(n)：创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。