多线程、高并发及线程安全、volatile关键字、原子性、并发包、线程池、线程状态、定时器

最新推荐文章于 2024-08-26 22:12:09 发布

农村小白i

最新推荐文章于 2024-08-26 22:12:09 发布

阅读量292

点赞数

分类专栏： JavaSE 文章标签：多线程线程池线程安全

本文链接：https://blog.youkuaiyun.com/weixin_44365508/article/details/119360271

版权

JavaSE 专栏收录该内容

10 篇文章

订阅专栏

本文详细介绍了多线程的基本概念、线程安全问题及其解决方案，包括volatile关键字、原子类、synchronized关键字等，并深入探讨了线程池、线程状态、定时器等高级主题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

多线程、高并发及线程安全、volatile关键字、原子性、并发包、线程池、线程状态、定时器

一、多线程

1.1 并发与并行

并发：指两个或者多个事件，在同一时间段内发生（交替执行）。
并行：指两个或者多个事件，在同一时刻发生（同时执行）

$[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-7oa4fktb-1627999442831)(E:\itheima\Node\JavaSE\images\image14.png)]$

在操作系统中，安装了多个程序

并发是指的是在一段时间内宏观上有多个程序同时运行，这在单CPU系统中，每一时刻只能有一道程序执行，即微观上这些程序是分时的交替运行，只不过给人的感觉是同时运行，那是因为分时的交替运行的时间是非常短的。
而在多个 CPU 系统中，则这些可以并发执行的程序便可以分配到多个处理器上（CPU），实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序，这样多个程序便可以同时执行。目前电脑市场上说的多核 CPU，便是多核处理器，核越多，并行处理的程序越多，能大大的提高电脑运行的效率。

注意：单核处理器的计算机肯定是不能并行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理,线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行，当系统只有一个CPU时，线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。

1.2 线程与进程

进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程；进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程
线程：是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

进程与线程的区别

**进程：**有独立的内存空间，进程中的数据存放空间（堆空间和栈空间）是独立的，至少有一个线程。
**线程：**堆空间是共享的，栈空间是独立的，线程消耗的资源比进程小的多。

**注意：**下面内容为了解知识点

1:因为一个进程中的多个线程是并发运行的，那么从微观角度看也是有先后顺序的，哪个线程执行完全取决于 CPU 的调度，程序员是干涉不了的。而这也就造成的多线程的随机性。

2:Java 程序的进程里面至少包含两个线程，主进程也就是 main()方法线程，另外一个是垃圾回收机制线程。每当使用 java 命令执行一个类时，实际上都会启动一个 JVM，每一个 JVM 实际上就是在操作系统中启动了一个线程，java 本身具备了垃圾的收集机制，所以在 Java 运行时至少会启动两个线程。

3:由于创建一个线程的开销比创建一个进程的开销小的多，那么我们在开发多任务运行的时候，通常考虑创建多线程，而不是创建多进程。

线程调度：

分时调度：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间。
抢占式调度：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)

Java使用的为抢占式调度。

多线程随机打印的原理：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-R4bmHmcW-1627999442834)(images/image27.png)]

1.3 Thread类

线程开启我们需要用到了 java.lang.Thread 类，API中该类中定义了有关线程的一些方法，具体如下

构造方法：

public Thread() :分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

常用方法：

public String getName() :获取当前线程名称。
public void start() :导致此线程开始执行; Java虚拟机调用此线程的run方法。
public void run() :此线程要执行的任务在此处定义代码。
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。

创建线程的方式总共有两种，一种是继承Thread类方式，一种是实现Runnable接口方式

1.4 创建线程的方式一_继承Thread方式

Java使用 java.lang.Thread 类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Thread类来创建并启动多线程的步骤如下：

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务,因此把run()方法称为线程执行体。
创建Thread子类的实例，即创建了线程对象
调用线程对象的start()方法来启动该线程

/* 自定义线程（继承Thread类） */
public class MyThread extends Thread {
    // 定义指定线程名称的构造方法
    public MyThread(String name){
        // 调用父类的String参数的构造方法，指定线程的名称
        super(name);
    }
    // 不指定线程的名字,线程有默认的名字Thread-0 
    public MyThread(){}
    
    /**
     * 重写run方法，完成该线程执行的逻辑
     */
    @Override
    public void run(){
        for (int i = 0; i < 200; i++) {
            System.out.println(getName() + "：正在执行！" + i);
        }
    }
}

/* 测试类 */
public class Main {
    public static void main(String[] args) {
        // 创建自定义线程的对象
        MyThread mt = new MyThread("新的线程！");
        // 开启线程
        mt.start();
        // 在主方法中执行for循环
        for (int i = 0; i < 200; i++) {
            System.out.println("main线程！" + i);
        }
    }
}

1.5 创建线程的方式二_实现Runnable接口方式【常用】

采用 java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。

步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

/* 自定义类（实现Runnable接口） */
public class MyRunnable implements Runnable {
    /**
     * 重写run方法，完成该线程执行的逻辑
     */
    @Override
    public void run(){
        for (int i = 0; i < 200; i++) {
            System.out.println((Thread.currentThread().getName() + "：正在执行！" + i);
        }
    }
}

/* 测试类 */
public class Main {
    public static void main(String[] args) {
        // 创建自定义类的对象
        MyRunnable mr = new MyRunnable();
        // 创建线程对象
        Thread t = new Thread(mr, "令狐冲");
        // 开启线程
        t.start();
        // 在主方法中执行for循环
        for (int i = 0; i < 200; i++) {
            System.out.println("风清扬" + i);
        }
    }
}

通过实现Runnable接口，使得该类有了多线程类的特征。run()方法是多线程程序的一个执行目标。所有的多线程代码都在run方法里面。Thread类实际上也是实现了Runnable接口的类。

在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target) 构造出对象，然后调用Thread对象的start()方法来运行多线程代码

实际上所有的多线程代码都是通过运行Thread的start()方法来运行的。因此，不管是继承Thread类还是实现Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

Runnable对象仅仅作为Thread对象的target，Runnable实现类里包含的run()方法仅作为线程执行体。而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

Thread和Runnable的区别

如果一个类继承Thread，则不适合资源共享。但是如果实现了Runable接口的话，则很容易的实现资源共享。

总结：

实现Runnable接口比继承Thread类所具有的优势：

适合多个相同的程序代码的线程去共享同一个资源。
可以避免java中的单继承的局限性。
增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

1.6 匿名内部类

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

public class Main {
    public static void main(String[] args) throws InterruptedException {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "---" + i);
                }
            }
        }, "runnable").start();

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "---" + i);
        }
    }
}

线程创建之后，只能启动一次。如果想要多次执行线程任务，需要创建多个线程，通过多个线程调用start方法。

二、高并发及线程安全

2.1 高并发及线程安全概念

**高并发：**是指在某个时间点上，有大量的用户(线程)同时访问同一资源。例如：天猫的双11购物节、12306的在线购票在某个时间点上，都会面临大量用户同时抢购同一件商品/车票的情况。
**线程安全：在某个时间点上，当大量用户(线程)访问同一资源时，而同一资源的代码不具有原子性，由于多线程运行机制的原因，可能会导致被访问的资源出现"数据污染"**的问题。

线程安全问题都是由多个线程同时访问全局变量及静态变量引起的
高并发所产生的安全性问题主要表现

1.可见性：指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

2.有序性：即程序执行的顺序按照代码的先后顺序执行。

3.原子性：即一个操作或者多个操作(多行代码) 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行

2.2 多线程的运行机制&&Java内存模型

当一个线程启动后，JVM会为其分配一个独立的"线程栈区"，这个线程会在这个独立的栈区中运行。

/** 自定义线程类，继承Thread类 */
public class MyThread extends Thread { 
    @Override public void run() { 
        for (int i = 0; i < 100; i++) { 
            System.out.println("i = " + i); 
        } 
    } 
}

/** 测试类 */
public class Main {
    public static void main(String[] args) { 
        //1.创建两个线程对象 
        MyThread t1 = new MyThread(); 
        MyThread t2 = new MyThread(); 
        
        //2.启动两个线程 
        t1.start(); 
        t2.start(); 
    }
}

启动后，内存的运行机制：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-IIMTruZ5-1627999442836)(images/image19.png)]

多个线程在各自栈区中独立、无序的运行，当访问一些代码，或者同一个变量时，就可能会产生一些问题

Java内存模型JMM

概述：JMM(Java Memory Model)Java内存模型,是java虚拟机规范中所定义的一种内存模型。

Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。

所有的共享变量都存储于主内存。这里所说的变量指的是实例变量(成员变量)和类变量(静态成员变量)。不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。每一个线程还存在自己的工作内存(栈内存)，线程的工作内存，保留了被线程使用的变量的工作副本。线程对变量的所有的操作(读，取)都必须在工作内存中完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存完成。

2.3 多线程的安全性问题（可见性、有序性、原子性）----可见性

例如下面的程序，先启动一个线程，在线程中将一个变量的值更改，而主线程却一直无法获得此变量的新值。

/** 自定义线程类，继承Thread */
public class MyThread extends Thread {
    public static int a = 0;

    @Override
    public void run() {
        System.out.println("线程启动，休息2秒");
        try {
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        a = 1;
        System.out.println("已经将a的值修改为1");
        System.out.println("线程结束");
    }
}
/** 测试类 */
public class Main {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        mt.start();

        while (true) {
            if (MyThread.a == 1) {
                System.out.println("主线程读到了a=1");
            }
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TzMXLseL-1627999442838)(images/image20.png)]

2.4 多线程的安全性问题（可见性、有序性、原子性）----有序性

多线程环境下，我们通常不希望对一些代码进行重排的！！！

有些时候“编译器”在编译代码时，会对代码进行“重排”，例如：

int a = 10; //1

int b = 20; //2

int c = a + b; //3

第一行和第二行可能会被“重排”：可能先编译第二行，再编译第一行，总之在执行第三行之前，会将1,2编译完毕。1和2 先编译谁，不影响第三行的结果。
但在“多线程”情况下，代码重排，可能会对另一个线程访问的结果产生影响：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9k9hXD5P-1627999442839)(images/image32.png)]

2.5 多线程的安全性问题（可见性、有序性、原子性）----原子性：【重点】

/**  自定义线程类 */
public class MyThread extends Thread { 
    public static int a = 0; 
    
    @Override 
    public void run() { 
        for (int i = 0; i < 10000; i++) { 
            a++; 
        }
        System.out.println("修改完毕！"); 
    } 
}

/** 测试类 */
public class Main { 
    public static void main(String[] args) throws InterruptedException {
        //1.启动两个线程
        MyThread t1 = new MyThread();
        MyThread t2 = new MyThread(); 
        t1.start(); 
        t2.start(); 
        Thread.sleep(1000); 
        System.out.println("获取a最终值：" + MyThread.a);
        //总是不准确的。原因：两个 线程访问a的步骤不具有：原子性
    } 
}

线程t1先读取a 的值为：0
t1被暂停
线程t2读取a的值为：0
t2将a = 1
t2将a写回主内存
t1将a = 1
t1将a写回主内存(将t2更改的1，又更改为1)
所以两次加1，但结果仍为1，少加了一次。
    //原因：两个线程访问同一个变量a的代码不具有"原子性"

原子性原理&&内存工作原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W4ZqlZyh-1627999442840)(images/image33.png)]

三、volatile关键字（只解决“变量”的可见性、有序性）【重点】

3.1 什么是volatile关键字

volatile是一个"变量修饰符"，它只能修饰"成员变量"，它能强制线程每次从主内存获取值，并能保证此变量不会被编译器优化。
volatile能解决变量的可见性、有序性；
volatile不能解决变量的原子性

3.2 volatile解决可见性

当变量被修饰为volatile时，会迫使其他线程的变量副本失效，会迫使线程每次使用此变量，都会去主内存获取变量值，保证其可见性

/** 自定义线程类，继承Thread */
public class MyThread extends Thread {
    public static volatile int a = 0;

    @Override
    public void run() {
        System.out.println("线程启动，休息2秒");
        try {
            Thread.sleep(2 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        a = 1;
        System.out.println("已经将a的值修改为1");
        System.out.println("线程结束");
    }
}
/** 测试类 */
public static void main(String[] args) throws InterruptedException {
    MyThread mt = new MyThread();
    mt.start();
    while (true) {
        if (MyThread.a == 1) {
            System.out.println("主线程读到了a=1");
        }
    }
}

3.3 volatile解决有序性

当成员变量被修饰为volatile时，会禁止java编译器(javac.exe)编译成.class文件时，不会对代码重排

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kg7vn9fq-1627999442842)(images/image23.png)]

3.4 volatile不能解决原子性

volatile不能把原子性的三步（读改存）转变成一步执行

public class MyThread extends Thread {    
	public static volatile int a = 0;   
	@Override     
	public void run() {        
		for (int i = 0; i < 10000; i++) {    
			//线程1：取出a的值a=0(被暂停)           
			a++; //写回        
		}        
		System.out.println("修改完毕！");    
	}
}
public class Main {    
	public static void main(String[] args) throws InterruptedException {         
		//1.启动两个线程        
		MyThread t1 = new MyThread();         
		MyThread t2 = new MyThread();        
		t1.start();         
		t2.start();        
		Thread.sleep(1000);         
		System.out.println("获取a最终值：" + MyThread.a);//最终结果仍然不正确。     
	} 
}

所以，volatile关键字只能解决"变量"的可见性、有序性问题，并不能解决原子性问题

四、原子类（解决变量的可见性、有序性）

4.1 原子类概述

在java.util.concurrent.atomic包下定义了一些对“变量”操作的“原子类”:

1).java.util.concurrent.atomic.AtomicInteger：对int变量操作的“原子类”;

2).java.util.concurrent.atomic.AtomicLong：对long变量操作的“原子类”;

3).java.util.concurrent.atomic.AtomicBoolean：对boolean变量操作的“原子类”;

它们可以保证对“变量”操作的：可见性、有序性、原子性。

4.2 AtomicInteger类示例

/** 线程类 */
public class MyThread extends Thread {    
	public static AtomicInteger a = new AtomicInteger(0);  
	  	@Override   
	  	public void run() {        
	  		for (int i = 0; i < 10000; i++) { 
	  		   // a++   
	  		   a.getAndIncrement();       
	  		}        
	  		System.out.println("修改完毕");    
	  	}
}
/** 测试类 */
public static void main(String[] args) throws InterruptedException {   
	 MyThread mt1 = new MyThread();   
	 mt1.start();  
	 MyThread mt2 = new MyThread(); 
	 mt2.start();   
	 Thread.sleep(2 * 1000);   
	 System.out.println("最终值" + MyThread.a.get());
}

我们能看到，无论程序运行多少次，其结果总是正确的！

4.3 AtomicInteger类的工作原理-CAS机制【乐观锁】

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iz4H88k3-1627999442843)(images/image24.png)]

在Unsafe类中，调用了一个：**compareAndSwapInt()**方法，此方法的几个参数：

var1：传入的AtomicInteger对象
var2：AtommicInteger内部变量的偏移地址
var5：之前取出的AtomicInteger中的值；
var5 + var4：预期结果

此方法使用了一种"比较并交换(Compare And Swap)"的机制，它会用var1和var2先获取内存中AtomicInteger中的值，然后和传入的，之前获取的值var5做一下比较，也就是比较当前内存的值和预期的值是否一致，如果一致就修改为var5 + var4，否则就继续循环，再次获取AtomicInteger中的值，再进行比较并交换，直至成功交换为止。

//compareAndSwapInt()方法是"线程安全"的。我们假设两个线程交替运行的情况，看看它是怎样工作的：
- 初始AtomicInteger的值为0
- 线程A执行：var5 = this.getIntVolatile(var1,var2);
- 获取的结果为：0
- 线程A被暂停
- 线程B执行：var5 = this.getIntVolatile(var1,var2);获取的结果为：0
- 线程B执行：this.compareAndSwapInt(var1,var2,var5,var5 + var4)
- 线程B成功将AtomicInteger中的值改为1
- 线程A恢复运行，执行：this.compareAndSwapInt(var1,var2,var5,var5 + var4)
- 此时线程A使用var1和var2从AtomicInteger中获取的值为：1，而传入的var5为0，比较失败，返回false，继续循环。
- 线程A执行：var5 = this.getIntVolatile(var1,var2);获取的结果为：1
- 线程A执行：this.compareAndSwapInt(var1,var2,var5,var5 + var4)
- 此时线程A使用var1和var2从AtomicInteger中获取的值为：1，而传入的var5为1，比较成功，将其修改为var5 + var4，也就是2，将AtomicInteger中的值改为2，结束。

什么是CAS：

CAS机制也被称为：乐观锁。因为大部分比较的结果为true，就直接修改了。只有少部分多线程并发的情况会导致CAS失败，而再次循环

4.4 AtomicIntegerArray类示例

常用的对数组操作的原子类：

1).java.util.concurrent.atomic.AtomicIntegetArray:对int数组操作的原子类。
2).java.util.concurrent.atomic.AtomicLongArray：对long数组操作的原子类。
3).java.utio.concurrent.atomic.AtomicReferenceArray：对引用类型数组操作的原子类。

/** 自定义线程 */
public class MyThread extends Thread {   
	private static int[] array = new int[1000];//定义一个数组    
	//改用原子类，使用数组构造    
	public static AtomicIntegerArray arr = new AtomicIntegerArray(array);    
	@Override    
	public void run() {        
		for (int i = 0; i < arr.length(); i++) {            
			arr.addAndGet(i, 1);//将i位置上的元素 + 1 
		}        
	}    
}
/** 测试类 */
public class Main {    
	public static void main(String[] args) throws InterruptedException {        
	for (int i = 0; i < 1000; i++) {            
		new MyThread().start();        
	}        
	Thread.sleep(1000 * 5);//让所有线程执行完毕        
	System.out.println("主线程休息5秒醒来");        
	for (int i = 0; i < MyThread.arr.length(); i++) {            
		System.out.println(MyThread.arr.get(i));        
	}    
}

五、synchronized关键字(解决可见性、有序性、原子性)【悲观锁】

5.1 多行代码的原子性问题

电影院要卖票，我们模拟电影院的卖票过程。假设要播放的电影是 “葫芦娃大战奥特曼”，本次电影的座位共100个(本场电影只能卖100张票)。我们来模拟电影院的售票窗口，实现多个窗口同时卖 “葫芦娃大战奥特曼”这场电影票(多个窗口一起卖这100张票)需要窗口，采用线程对象来模拟；需要票，Runnable接口子类来模拟。

/** 模拟卖票 */
public class MyRunnable implements Runnable {    
	public int ticket = 100;    
	@Override    
	public void run() {        
		while (true) {            
			if (ticket > 0) {                
				try {                    
					Thread.sleep(1000);                
				} catch (InterruptedException e) {                    
					e.printStackTrace();                
				}                
				System.out.println(Thread.currentThread().getName() + "正在卖---" + ticket--);            
			}         
		}    
	}
}
/** 测试类 */
public class Main {    
	public static void main(String[] args) throws InterruptedException {       
		MyRunnable ticket = new MyRunnable();        
		new Thread(ticket,"窗口1").start();        
		new Thread(ticket,"窗口2").start();        
		new Thread(ticket,"窗口3").start();    
	}
}

发现程序出现了两个问题：

相同的票数,比如5这张票被卖了两回。
不存在的票，比如0票与-1票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

线程安全问题都是由全局变量及静态变量引起的。而每个线程操作这个变量都需要很多步骤：获取变量的值、打印变量的值、更改变量的值，而一个线程在执行某一步骤时都可能被暂停，而另一个线程会执行，这同样会导致多个线程访问同一个变量，最终导致这个变量的值不准确。

5.2 synchronized关键字概述

synchronized关键字：表示“同步”的。它可以对“多行代码”进行“同步”——将多行代码当成是一个完整的整体，一个线程如果进入到这个代码块中，会全部执行完毕，执行结束后，其它线程才会执行。这样可以保证这多行的代码作为完整的整体，被一个线程完整的执行完毕。
synchronized被称为**“重量级的锁”方式，也是“悲观锁”**——效率比较低。
synchronized有几种使用方式：

a).同步代码块

b).同步方法【常用】

当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题。

要解决上述多线程并发访问一个资源的安全性问题:也就是解决重复票与不存在票问题，Java中提供了同步机制(synchronized)来解决。

5.3 同步代码块（解决可见性、有序性、原子性）

同步代码块： synchronized 关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。

格式:

synchronized(同步锁){     需要同步操作的代码}

同步锁（对象锁、对象监视器）

对象的同步锁只是一个概念,可以想象为在对象上标记了一个锁.

1. 锁对象可以是任意类型。

2. 多个线程对象要使用同一把锁。

注意:在任何时候,最多允许一个线程拥有同步锁,谁拿到锁就进入代码块,其他的线程只能在外等着(BLOCKED)。

使用同步代码块解决代码：当使用了同步代码块后，上述的线程的安全问题，解决了。

public class MyRunnable implements Runnable {    
	public static volatile int ticket = 100;    
		Object lock = new Object();    
		@Override    
		public void run() {        
			while (true) {            
				synchronized (lock) {                
					if (ticket > 0) {                    
						try {                        
							Thread.sleep(50);                
						} catch (InterruptedException e) {                        
							e.printStackTrace();                    
						}                    
						System.out.println(Thread.currentThread().getName() + "正在卖---" + ticket--);                
					}            
				}        
			}    
		}
	}

5.4 同步方法【常用】

同步方法:使用synchronized修饰的方法,就叫做同步方法,保证A线程执行该方法的时候,其他线程只能在方法外等着

格式：

public synchronized void method(){可能会产生线程安全问题的代码}

同步锁是谁?

对于非static方法,同步锁就是this。this == 在其他类中new的当前类的对象

对于static方法（在创建对象之前进入静态代码区），我们使用当前方法所在类的字节码对象(类名.class)。

public class MyRunnable implements Runnable {    
	public int ticket = 100;    
	@Override    
	public void run() {        
		while (true) {            
			sellTicket();        
		}    
	}    
/*      锁对象 是 谁调用这个方法 就是谁          
		隐含 锁对象 就是 this（new MyRunnable对象）     
*/    
	private synchronized void sellTicket() {        
		if (ticket > 0) {            
			try {                
				Thread.sleep(50);            
			} catch (InterruptedException e) {                
				e.printStackTrace();            
			}            
			System.out.println(Thread.currentThread().getName() + "正在卖---" + ticket--);       
		}  
	}
}

5.5 Lock锁(锁为创建的lock对象)【悲观锁】

java.util.concurrent.locks.Lock 机制提供了比synchronized代码块和synchronized方法更广泛的锁定操作,同步代码块/同步方法具有的功能Lock都有,除此之外更强大

锁对象为ReenTrantLock的对象

Lock锁也称同步锁，加锁与释放锁方法化了，如下：

public void lock() :加同步锁。
public void unlock() :释放同步锁。

public class MyRunnable implements Runnable {    
	public int ticket = 100;    
	Lock lock = new ReentrantLock();    
	@Override    
	public void run() {        
		while (true) {            
			lock.lock(); // 锁为lock            
			if (ticket > 0) {                
				try {                    
					Thread.sleep(50);                
				} catch (InterruptedException e) {                    
					e.printStackTrace();                
				}                
				System.out.println(Thread.currentThread().getName() + "正在卖---" + ticket--);            
			}            
			lock.unlock();        
		}   
	}
}

六、并发包

在JDK的并发包里提供了几个非常有用的并发容器和并发工具类。供我们在多线程开发中进行使用。

6.1 CopyOnWriteArrayList【重点】

ArrayList的线程不安全
CopyOnWriteArrayList是线程安全的，底层采用了CAS(乐观锁)技术
Vector集合也是线程安全的，底层使用的是synchronized技术，效率低已经被淘汰

// 定义线程类
public class MyThread extends Thread {     
	// public static List<Integer> list = new ArrayList<>();//线程不安全的    
	//改用：线程安全的List集合:    
	public static CopyOnWriteArrayList<Integer> list = new CopyOnWriteArrayList<>();        
	@Override    
	public void run() { 
		for (int i = 0; i < 10000; i++) {             
	    	list.add(i);         
	    }        
	    System.out.println("添加完毕！");    
	} 
}
// 测试类
public class Demo {     
	public static void main(String[] args) throws InterruptedException {         
		MyThread t1 = new MyThread();        
		MyThread t2 = new MyThread();                
		t1.start();        
		t2.start();                 
		Thread.sleep(1000);         
		System.out.println("最终集合的长度：" + MyThread.list.size());    
	} 
}

6.2 CopyOnWriteArraySet【重点】

HashSet仍然是线程不安全的
CopyOnWriteArraySet是线程安全的，【乐观锁】

// 线程类
public class MyThread extends Thread {    
	// public static Set<Integer> set = new HashSet<>();//线程不安全的     
	//改用：线程安全的Set集合:    
	public static CopyOnWriteArraySet<Integer> set = new CopyOnWriteArraySet<>();         
	@Override     
	public void run() {         
		for (int i = 0; i < 10000; i++) {             
			set.add(i);         
		}
		System.out.println("添加完毕！");    
	} 
}
// 测试类
public class Demo {    
	public static void main(String[] args) throws InterruptedException {         
		MyThread t1 = new MyThread();         
		t1.start();                 
		//主线程也添加10000个         
		for (int i = 10000; i < 20000; i++) {             
			MyThread.set.add(i);        
		}        
		Thread.sleep(1000 * 3);        
		System.out.println("最终集合的长度：" + MyThread.set.size());     
	}
}

6.3 ConcurrentHashMap【重点】

HashMap是线程不安全的
ConcurrentHashMap是线程安全的，但效率高
Hashtable是线程安全的，底层使用的是synchronized技术，效率低

public synchronized V put(K key, V value)

public synchronized V get(Object key)

Hashtable容器使用synchronized来保证线程安全，但在线程竞争激烈的情况下Hashtable的效率非常低下。因为当一个线程访问Hashtable的同步方法，其他线程也访问Hashtable的同步方法时，会进入阻塞状态。如线程1使用put进行元素添加，线程2不但不能使用put方法添加元素，也不能使用get方法来获取元素，所以竞争越激烈效率越低。

七、线程池(只能接收实现Runnable与Callable接口的类对象)

7.1线程池的概念

**线程池：**其实就是一个容纳多个线程的容器，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多资源。
线程池的工作原理：
合理利用线程池能够带来三个好处：

1.降低资源消耗。减少了创建和销毁线程的次数，每个工作线程都可以被重复利用，可执行多个任务。

2.提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。

3.提高线程的可管理性。可以根据系统的承受能力，调整线程池中工作线线程的数目，防止因为消耗过多的内存，而把服务器累趴下(每个线程需要大约1MB内存，线程开的越多，消耗的内存也就越大，最后死机)。

7.2 线程池的使用

Java里面线程池的顶级接口是 java.util.concurrent.Executor ，但是严格意义上讲 Executor 并不是一个线程池，而只是一个执行线程的工具。真正的线程池接口是java.util.concurrent.ExecutorService。

要配置一个线程池是比较复杂的，尤其是对于线程池的原理不是很清楚的情况下，很有可能配置的线程池不是较优的，因此在 java.util.concurrent.Executors 线程工厂类里面提供了一些静态工厂，生成一些常用的线程池。官方建议使用Executors工程类来创建线程池对象。

Executors类中有个创建线程池的方法如下

public static ExecutorService newFixedThreadPool(int nThreads) ：返回线程池对象。(创建的是有界线程池,也就是池中的线程个数可以指定最大数量)
定义了一个使用线程池对象的方法如下：

public Future<?> submit(Runnable task) :获取线程池中的某一个线程对象，并执行一个无返回值的线程任务

public Future<?> submit(Callable task)：获取线程池中的某一个线程对象，并执行一个有返回值的线程任务

Future接口：用来记录线程任务执行完毕后产生的结果。

使用线程池中线程对象的步骤：

1.创建线程池对象。

2.创建Runnable接口子类对象。(task)

3.提交Runnable接口子类对象。(take task)

4.关闭线程池(一般不做)。

/**
 * Runnable实现类代码
 */
public class MyRunnable implements Runnable {
    @Override
    public void run() {
        System.out.println("我要一个教练");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("教练来了" + Thread.currentThread().getName());
        System.out.println("教练教我游泳，教完后，教练回到了泳池");
    }
}

/**
 * 线程池测试类
 */
public class ThreadPoolDemo {
    public static void main(String[] args) {        
        // 创建线程池对象        
        ExecutorService service = Executors.newFixedThreadPool(2); //包含两个线程对象        
        // 创建Runnable实列对象        
        MyRunnable mr = new MyRunnable();        
        // 从线程池中获取线程对象,然后调用MyRunnable中的run()        
        service.submit(mr);        
        // 再获取个线程对象，调用MyRunnable中的run()        
        service.submit(mr);        
        // 注意：submit方法调用结束后，程序并不终止，是因为线程池控制了线程的关闭。将使用完的线程又归还到了线程池中        
        // 关闭线程池        
        // service.shutdown();    
    }
}

Callable测试代码:

Future submit(Callable task) : 获取线程池中的某一个线程对象，并执行Future : 表示计算的结果.
V get() : 获取计算完成的结果。

public class ThreadPoolDemo2 {
    public static void main(String[] args) throws Exception {
        // 创建新线程池对象        
        ExecutorService executorService = Executors.newFixedThreadPool(2);// 包含两个线程对象        
        // 创建Callable实例对象        
        Callable<Double> c = new Callable<Double>() {
            @Override
            public Double call() throws Exception {
                return Math.random();
            }
        };
        // 从线程池中获取线程对象,然后调用Callable中的call()      
        Future<Double> f1 = executorService.submit(c);
        // Future 调用get()获取运算结果      
        System.out.println(f1.get());
        Future<Double> f2 = executorService.submit(c);
        System.out.println(f2.get());
        Future<Double> f3 = executorService.submit(c);
        System.out.println(f3.get());
    }
}

7.3 线程池的练习

**需求:**使用线程池方式执行任务,返回1-n的和

**分析:**因为需要返回求和结果,所以使用Callable方式的任务

/**
 * callable实现类
 */
public class MyCallable implements Callable<Integer> {
    private int n = 0;

    public MyCallable(int n) {
        this.n = n;
    }

    @Override
    public Integer call() throws Exception {
        return sum(n);
    }

    private int sum(int n) {
        if (n == 1) {
            return 1;
        }
        return n + sum(n - 1);
    }
}

/**
 * 测试类
 */
public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = Executors.newFixedThreadPool(3);
        Future<Integer> sc = pool.submit(new MyCallable(100));
        System.out.println("结果" + sc.get());
        Future<Integer> sc2 = pool.submit(new MyCallable(100));
        System.out.println("结果" + sc2.get());
        Future<Integer> sc3 = pool.submit(new MyCallable(100));
        System.out.println("结果" + sc3.get());
    }
}

八、线程状态

8.1 线程状态概述

线程由生到死的完整过程：技术素养和面试的要求。

线程状态	导致状态发生的条件
new(新建)	线程刚被创建，但是并未启动。还没调用start方法。MyThread t = new MyThread只有线程对象，没有线程特征。
Runnable(可运行)	线程可以在java虚拟机中运行的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器。调用了t.start()方法：就绪（经典叫法）
Blocked(锁阻塞)	当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。
Waiting(无限等待)	一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能够唤醒。
Timed Waiting(计时等待)	同waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep 、Object.wait。
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ZdOpSrP0-1627999442848)(images/image29.png)]

8.2 睡眠sleep方法

我们看到状态中有一个状态叫做计时等待，可以通过Thread类的方法来进行演示.

public static void sleep(long time) 让当前线程进入到睡眠状态，到毫秒后自动醒来继续执行

public class Test {
    public static void main(String[] args) {
        for (int i = 1; i <= 5; i++) {
            Thread.sleep(1000);
            System.out.println(i);
        }
    }
}

8.3 等待(wait)和唤醒(notify)（必须使用锁对象调用）

Object类的方法

void notify() 唤醒在此对象监视器(同步锁,对象锁)上等待的单个线程。

如果有多个线程在睡眠，会唤醒最先进行睡眠的线程
void notifyAll() 唤醒在此对象监视器(同步锁,对象锁)上等待的所有线程。

public void wait() : 让当前线程进入到等待状态此方法必须锁对象调用。

public class Main_wait {
    public static void main(String[] args) {
        new Thread(() -> {
            try {
                System.out.println("wait start...");
                synchronized ("") {
                    "".wait();
                }
                System.out.println("wait over...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

public void notify() : 唤醒当前锁对象上等待状态的线程此方法必须锁对象调用。

public class Main_notify {
    public static void main(String[] args) throws InterruptedException {
        // 步骤1 : 子线程开启,进入无限等待状态, 没有被唤醒,无法继续运行.
        new Thread(() -> {
            try {
                System.out.println(Thread.currentThread().getName() + " begin wait...");
                synchronized ("lock") {
                    "lock".wait();
                }
                System.out.println(Thread.currentThread().getName() + " wait over...");
            } catch (InterruptedException e) {
            }
        }).start();

        // 步骤2: 加入如下代码后, 3秒后,会执行notify方法, 唤醒wait中线程.
        Thread.sleep(3000);
        new Thread(() -> {
            try {
                synchronized ("lock") {
                    System.out.println(Thread.currentThread().getName() + " 执行notify()方法，唤醒");
                    "lock".notify();
                }
            } catch (Exception e) {
            }
        }).start();
    }
}

注意：

使用在同步代码块中
一般使用wait()和notify()方法
在同步线程中，调用wait方法进入睡眠状态，会释放锁对象

九、定时器

9.1 定时器概述

定时器，可以设置线程在某个时间执行某件事情，或者某个时间开始，每间隔指定的时间反复的做某件事情

9.2 定时器Timer类

java.util.Timer类：线程调度任务以供将来在后台线程中执行的功能。任务可以安排一次执行，或者定期重复执行。

构造方法
```
public Timer()：构造一个定时器
```

成员方法

返回值	方法名	说明
void	schedule(TimerTask task, long delay)	在指定的延迟之后安排指定的任务执行。
void	schedule(TimerTask task, long delay,long period)	在指定的延迟之后开始，重新执行固定延迟执行的指定任务。
void	schedule(TimerTask task, Date time)	在指定的时间安排指定的任务执行。如果执行时间<当前时间，会直接执行定时任务
void	schedule(TimerTask task, Date fifirstTime, long period)	从指定的时间开始，对指定的任务执行重复的固定延迟执行。

public class Main {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //1.设置一个定时器，2秒后启动，只执行一次
        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                for (int i = 10; i >= 0; i--) {
                    System.out.println("倒数：" + i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("嘭...嘭...");
                timer.cancel();
            }
        }, 2000);

        //2.设置一个定时器，5秒后开始执行，每一秒执行一次
        Timer timer2 = new Timer();
        timer2.schedule(new TimerTask() {
            @Override
            public void run() {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                System.out.println(sdf.format(new Date()));
            }
        }, 5000, 1000);

        //3.设置一个定时器，在2030年01月01日零时开始执行，每隔24小时执行一次
        Timer timer3 = new Timer();
        Calendar c = new GregorianCalendar(2030, 1 - 1, 0, 0, 0);
        Date d = c.getTime();
        timer3.schedule(new TimerTask() {
            @Override
            public void run() {
                System.out.println("搜索全盘...");
            }
        }, d, 1000 * 3600 * 24);
    }
}