1. 基本概念：程序、进程、线程
-
程序 (program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
-
进程(process) 是程序的一次执行任务，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期
- 如: 运行中的QQ、运行中的MP3播放器
- 程序是静态的，进程是动态的
- 进程作为资源分配的单位，系统在运行时会为每个进程分配不同的内存区域
-
线程(thread):进程可进一步细化成线程，是一个程序内部的一条执性路径。
- 若一个进程同一时间并行执行多个线程，就是支持多线程的。
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc) ，线程切换的开销小。
- 一个进程中的多个线程共享相同的内存单元/内存地址空间——它们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程空间通信更简便、高效、但多个线程操作共享的系统资源可能就会带来安全的隐患。
举一个例子体现多线程，以360为例：
同时进行多个任务，如木马查杀，电脑清理，系统修复等等
打开任务管理器，cpu为这些线程分配资源。
在Java中，我们最常见的main方法就是一个线程。
这些目录中包含的代码都是静态代码。
点开文件中的代码，代码就跑起来后，打开任务管理器，此时就是一个运行起来的程序，我们叫做进程。
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FgVWdNhR-1669354936900)(D:\Java程序文档\img\image-20221125130157305.png)]](https://img-blog.csdnimg.cn/ea602996726441b0bb7a50b4e9566df9.png)
- 单核CPU和多核CPU的理解
- 若一个进程同一时间并行执行多个线程，就是支持多线程的。
- 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小。
- 一个进程中的多个线程共享相同的内存单元/内存地址空间——它们从同一堆中分配对象，可以访问相同的变量和对象，这就使得线程空间通信更简便、高效、但多个线程操作共享的系统资源可能就会带来安全的隐患。
- 并行与并发
- 并行:多个CPU同时执行多个任务。比如:多个人同时做不同的事。
- 并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀、多个人做同一件事。
-
以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成的时间更短，为何仍需多线程呢？
-
多线程程序的优点:
- 提高应用程序的响应，对图形化界面更有意义，可增强用户体验
- 提高计算机系统CPU的利用率
- 改善程序结构，将既长又复杂的进程分成多个线程，独立运行，利于理解和修改
-
-
何时需要多线程
- 程序需要同时执行两个或多个任务
- 程序需要实现一些等待的任务时，如用户输入、文件读写操作、网路操作、搜索等。
- 需要一些后台运行的程序时。
2. 线程的创建和使用
2.1 线程的创建和启动
首先我们来看下面一个程序是否为多线程
public class Sample{
public void method1(String str){
System.out.println(str);
}
public void method2(String str){
method1(str);
}
public static void main(String[] args){
Sample s=new Sample();
s.method2("hello");
}
}
很明显，上述程序不是多线程，该程序首先从main()进入，调用Sample类的method2，method2又调用method1，一条线将程序执行完。
-
线程的创建和启动
-
Java语言的JVM允许程序运行多个线程，它通过java.long.Thread类来体现
-
Thread类的特性
-
每个线程都是通过某个特定Thread对象的run()方法来完成操作的，经常把run()方法的主体称为线程体
-
通过该Thread对象的start()方法来启动这个线程，而非直接调用run()
-
-
2.1.1 方法一——重写Thread类中run()方法
打开Java API,查看Thread类的定义。
Java API 的Thread类中提供了两种创建线程的方式
创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。
示例如下：
class MyThread extends Thread{ @Override public void run() { // 要重写的run方法 } }
下列代码会创建并启动一个线程：
MyThread t1 = new MyThread();
t1.start();
package com.Liang.java;
/**
* 多线程的创建，方式一：继承于Thread类的方式
* 1.创建一个继承于Thread类的子类
* 2.重写Thread类的Run()方法 --> 将此线程进行的操作声明在run()中
* 3创建Thread类的子类的对象
* 4.通过此对象调用start()方法
*
* 例子，遍历100以内的所有偶数
* Created on 2022/11/18.
*
* @author Mr Liang
*/
//1.创建一个继承于Thread类的子类
class MyThread extends Thread{
// 2.重写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创建Thread类的子类的对象
MyThread t1 = new MyThread();
// 4.通过此对象调用start()方法
// start()方法功能 :启动当前线程，调用当前线程的run()
t1.start();
// 问题1：不能通过直接调用run()的方式启动线程
// t1.run();直接用对象调用run方法，都在主线程中进行操作，变成了单线程
// 问题2：如何再启动一个线程?
// t1.start();不可以还让已经start()的线程去执行，会IllegalThreadStateException异常
// 新建一个子类对象，启动第二个线程
MyThread t12= new MyThread();
t12.start();
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName()+":"+i+"**********main()**********");
}
}
}
}
可以看到，程序运行过程中出现了交互。CPU为两个线程分配资源去同时执行程序。
如果有两个或两个以上的线程执行不同的操作时，可以创建两个Thread的子类，分别重写子类中的run()方法。
package com.Liang.exer;
/**
* 创建两个分线程，其中一个线程遍历100以内偶数，另一个遍历100以内奇数
* Created on 2022/11/18.
*
* @author Mr Liang
*/
class MyThread1 extends Thread{
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if(i%2==0)
System.out.println(Thread.currentThread().getName()+":"+i);
}
}
}
class MyThread2 extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
if(i%2!=0)
System.out.println(Thread.currentThread().getName()+"+"+i);
}
}
}
public class ThreadDemo {
public static void main(String[] args) {
MyThread1 t1 = new MyThread1();
MyThread2 t2= new MyThread2();
t1.start();
t2.start();
// 如果线程在进程只调用一次,可以使用创建Thread类的匿名子类方式
/* new Thread(){
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0)
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}.start();
new Thread(){
public void run() {
for (int i = 0; i < 100; i++) {
if(i%2!=0)
System.out.println(Thread.currentThread().getName()+"+"+i);
}
}
}.start();*/
}
}
2.1.2 方法二——声明实现 Runnable 接口的类
创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
示例如下：
class MyThread2 implements Runnable{ @Override public void run() { //要重写的run()方法 } }
下列代码会创建并启动一个线程：
MyThread2 t1 = new MyThread2();
new Thread(t1).start();
package com.Liang.java;
/**
* 创建多线程方式二，实现Runnable接口
* 1.创建一个实现Runnable接口的类
* 2.实现类去实现Runnable中的抽象方法
* 3.将此对象作为参数传递到Thread类的构造器中，创建Thread类对象
* 4.通过此对象调用start()
* <p>
* 遍历100以内所有偶数
*
* Created on 2022/11/18.
*
* @author Mr Liang
*/
//1.创建一个实现Runnable接口的类
class MyThread2 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 ThreadTest2 {
public static void main(String[] args) {
MyThread2 t1 = new MyThread2();
// 3.将此对象作为参数传递到Thread类的构造器中，创建Thread类对象
Thread h1 = new Thread(t1);
h1.setName("线程一");
// 4.通过此对象调用start() 启动该线程 / 调用当前该线程的run()方法-->调用了Runnable类型的target的run()方法
h1.start();
// 再启动一个线程
Thread h2 = new Thread(t1);
h2.setName("线程二");
h2.start();
}
}
分析如下代码：
h1.start();
这时候调用start()方法，实际上是调用Thread类中的方法，而MyThread2类实现的是Runnable接口，而继承的是Object类，为什么会实现MyThread2类中的方法？
查看一下源码
public void run() { if (target != null) { target.run(); } }、
private Runnable target;
target是Thread类当中声明为Runable类型的一个变量或属性，
public Thread(Runnable target) { this(null, target, "Thread-" + nextThreadNum(), 0); }
这是在创建对象时使用的构造器，参数恰好是target
创建的MyThread类t1对象传入给target，然后在调用Thread类中的run()方法时，调用target.run()，也就是调用t1.run()，调用了重写的run()方法。
2.2 线程的调度
-
调度策略
抢占式：高优先级的线程优先抢占CPU
-
Java的调度方法
- 同优先级线程组成先进先出队列（先到先服务），使用时间片策略
- 对高优先级，使用优先调度的抢占式策略，例如VIP客户优先享受高品质服务
2.3 线程的优先级
- 线程的优先级等级
- MAX_PRIORITY: 10
- MIN_PRIORITY: 1
- NORM_PRIORITY: 5
- 涉及的方法
- getPriority():返回线程优先级
- setPriorty(int newPriority):改变线程的优先级
- 说明
- 线程创建时继承父线程的优先级
- 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才调用
2.4 Thread类中的方法
- void start():启动线程，并执行对象的run()方法
- run()：线程在被调度时执行的操作
- String getName():返回线程的名称
- void setName(String name):设置该线程名称
- Static Thread currentThread():返回当前线程。在Thread子类中就是this,通常用于主线程和Runnable实现类
package com.Liang.java;
/**
* 测试Thread中的常用方法
* 1.start():启动当前线程，调用当前线程的run();
* 2.run():通常需要重写 Thread类中的run()方法，将创建的线程要执行的操作声明在此方法中
* 3.currentThread():静态方法，
* 4.getName():获取当前线程的名字返回当执行前代码的线程
* 5.setName():设置当前线程的名字
* 6.yield():释放当前cpu的执行权
* 7.join():在线程a中调用线程b的join();此时线程a就进入阻塞状态，直到线程b完全执行完以后，线程a才结束阻塞状态
* 8.stop():已过时，当执行此方法时，强制结束当前线程
* 9.sleep(long millitime):让当前线程“睡眠”指定的毫秒数，在指定的millitime毫秒时间内，当前线程是阻塞状态
* 10. isAlive():判断当前线程是否还存活
*
*
* 线程的优先级:
* 1.
* MAX_PRIORITY = 10
* MIN_PRIORITY = 1
* NORM_PRIORITY = 5
*2.如何获取和设置当前线程的优先级:
* getpriority():获取线程的优先级
* setpriority(int p):设置线程的优先级
*
* instruction：高优先级的线程要抢占低优先级线程CPU的执行权，只从概率上讲，高优先级的线程高概率的情况下
* 被执行，并不意味着只有当高优先级的线程执行完成后，低优先级的线程才执行。
*
* Created on 2022/11/18.
*
* @author Mr Liang
*/
class Threadmd extends Thread{
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
/* try {
sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}*/
System.out.println(Thread.currentThread().getName() + ":"+Thread.currentThread().getPriority() +":"+i);
}
// 子类不能抛比父类更宽泛的异常，只能是使用try...catch
if (i % 20 == 0)
this.yield();
// Thread.currentThread().yield();
}
}
public Threadmd(String name){
super(name);//也可使用Thread构造器设置线程名
}
}
public class ThreadMathodTest {
public static void main(String[] args) {
Threadmd h1 = new Threadmd("线程一");
// h1.getName("线程一");
h1.setPriority(Thread.MAX_PRIORITY);
h1.start();
Thread.currentThread().setName("主线程");
Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
for (int i = 0; i < 100; i++) {
if(i%2==0)
System.out.println(Thread.currentThread().getName()+":"+Thread.currentThread().getPriority() +":"+i);
/* if(i==20) {
try {
h1.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}*/
}
System.out.println(h1.isAlive());
}
}
2.5 继承Thread类创建线程的应用
package com.Liang.java;
import java.awt.*;
/**
* 创建三个窗口卖票，总票数为100张
* 会出现卖出同一张票的问题，涉及线程安全问题，待解决
* Created on 2022/11/18.
*
* @author Mr Liang
*/
class Window extends Thread{
private static int ticket=100;//每个对象共享一个资源对象
@Override
public void run() {
while (true){
if(ticket>0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
}else
break;
}
}
}
public class windowTest {
public static void main(String[] args) {
Window h1 = new Window();
Window h2 = new Window();
Window h3 = new Window();
h1.setName("窗口一");
h2.setName("窗口二");
h3.setName("窗口三");
h1.start();
h2.start();
h3.start();
}
}
由执行结果可以看出，三个窗口卖出了同一张票，这显然是不正确的，相当于两人的票相同，而有一张必为假票，这样就存在着线程安全问题。
2.6 实现Runnable接口的类创建线程的应用
package com.Liang.java;
/**
* 创建三个窗口卖票，总票数为100张
* 会出现卖出同一张票的问题，涉及线程安全问题，待解决
* Created on 2022/11/18.
*
* @author Mr Liang
*/
class window1 implements Runnable{
private int ticket=100;
@Override
public void run() {
while (true){
if(ticket>0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
}else
break;
}
}
}
public class windowTest1 {
public static void main(String[] args) {
window1 w = new window1();
Thread t1 = new Thread(w);
Thread t2 = new Thread(w);
Thread t3 = new Thread(w);//三个线程共用一个对象
t1.start();
t2.start();
t3.start();
}
}
通过只创建一个对象，一个对象放入了三个构造器当中，三个线程用的同一个window1类的对象，而成员变量ticket自然而然也就成为了共同操作的变量。该方法同样存在着线程安全的问题。
2.7 线程的分类
Java中的线程分为两类：一种是守护线程，一种是用户线程。
- 它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开。
- 守护线程是用来服务用户线程的，通过在start()方法前调用thread.setDaemon(true)可以把一个用户线程变成一个守护线程。
- Java垃圾回收就是一个典型的守护线程。
- 若JVM中都是守护线程，当前JVM退出。
- 形象理解:兔死狗烹、鸟尽弓藏。
3. 线程的生命周期
- JDK中用Thread.State类定义了线程的几种状态
要想实现多线程，必须在主线程中创建新的线程对象.。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：
- 新建：当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。
- 就绪：处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源
- 运行: 当就绪的线程被调用并获得CPU资源时，便进入运行状态。run()方法定义了线程的操作和功能。
- 阻塞: 在某种特殊情况下，被人为挂起或执行输入输出操作时，让出CPU并临时中止自己的执行，进入阻塞状态。
- 死亡：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束。
4. 线程的同步
-
问题的提出
- 多个线程执行的不确定性引起执行结果的不稳定。
- 多个线程对账本的共享，会造成操作的不完整性，会破坏数据。
-
优点
- 同步的方式，解决了线程的安全问题。
-
缺点
- 操作同步代码时，只能有一个线程参与，其他线程等待。相当于是一个单线程的等待过程，效率低。
以上述售票为例，在run()方法中添加sleep()方法
public void run() {
while (true){
if(ticket>0) {
try {
Thread.sleep(100);//线程阻塞一段时间
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
}else
break;
}
程序运行后发生出现了错误数据。原因是某一线程执行run()方法时，多个线程依次进入阻塞状态，当阻塞状态结束时，各自不能及时出run()方法，导致数据处理发生错误。
同样的，将sleep()放在打印方法之后，重票的概率会大大增加。
public void run() {
while (true){
if(ticket>0) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
ticket--;
}else
break;
}
}
- 在卖票过程中，出现了重票、错票----出现了线程的安全问题
- 问题出现的原因，当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票
- 如何解决:当一个线程a在操作ticket的时候，其他线程不能参与进来，直到线程a操作完ticket时，线程才可以开始操作ticket，这种情况即使线程a出现了阻塞，也不能改变。
- 在java中，我们通过同步机制，来解决线程的安全问题
- 利用同步代码块和同步方法来解决线程安全的问题
4.1 同步代码块处理实现Runnable的线程安全问题
格式：
、synchronized(同步监视器){
//需要被同步的代码
}
说明:
- 操作共享数据的代码，即为需要被同步的代码。——>不能包多了，也不能包少了。
- 共享数据:多个线程共同操作的变量，例如，ticket就是共享数据。
- 同步监视器，俗称：锁。任何一个类的对象都可以充当锁。
class Window2 extends Thread{
private static int ticket=100;
private static Object obj=new Object();
@Override
public void run() {
while (true){
synchronized (obj) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
} else
break;
}
}
}
}
在synchronized代码块中，只能有一个线程执行，其他线程不能抢占，相当于是一个单线程的过程，效率低。——— 局限性
要求多个线程必须共用同一把锁。
public void run() { Object obj=new Object(); while (true){ synchronized(obj) {
synchronized(new Object()) {
上述两种方式是不正确的，每次运行run()方法，锁的对象不是同一个。
其次就是要注意synchronized包含代码块的范围。
public void run() {
synchronized (obj) {
while (true){
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
} else
break;
}
}
}
}
synchronized在while循环外的情况(包多)：
这时其实是不会发生线程安全的问题的，但是是不符合题意的，此时当一个线程进入run()方法，在synchronized包含的代码块中，一个线程一个while循环就把所有的票卖光了，不能体现出多线程的执行。
synchronized包少的情况:
public void run() {
while (true){
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized (obj) {
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
} else
break;
}
}
}
}
将synchronized放在了sleep()方法后，这时就会出现线程安全的问题，因为单个线程进入run方法中不能一直执行完毕，会被阻塞，cpu分配给其他线程执行。
可以使用this关键字，将当前对象作为锁，这样就不用再另外创建一个对象。
synchronized (this)
4.2 同步代码块处理继承Thread类的线程安全问题
package com.Liang.java;
/**
* Created on 2022/11/21.
*
* @author Mr Liang
*/
class Window2 extends Thread{
private static int ticket=100;//每个对象共享一个资源对象
private static Object obj=new Object();
@Override
public void run() {
while (true){
synchronized (obj) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
} else
break;
}
}
}
}
public class windowTest2 {
public static void main(String[] args) {
Window2 h1 = new Window2();
Window2 h2 = new Window2();
Window2 h3 = new Window2();
h1.setName("窗口一");
h2.setName("窗口二");
h3.setName("窗口三");
h1.start();
h2.start();
h3.start();
}
}
同样可以创建一个对象作为同步监视器，但是继承Thread类方法创建的线程需要同时创建多个对象，在调用各自重写的run()方法时，导致每次创建不同的obj对象,多个线程没有共用一把锁。
把对象声明为static类型
private static Object obj=new Object();
这样就共用了同一把锁
可以拿当前类充当同步监视器，
synchronized (Window2.class)
相当于<!–Class 变量名=Window2.class—>
类加载机制，将class文件加载到堆内存中，创建Class对象。
这里创建的Class类的对象，window2.class只会加载一次。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
4.3 同步方法处理实现Runnable的线程安全问题
- 如果操作共享数据的代码完整的声明在一个方法中，不妨将此方法声明为同步的
- 同步方法就是在方法中加一个synchronized
定义同步方法，同步方法内存放的就是需要共享的数据。
private synchronized void show() {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
}
}
在run()方法中调用，
public void run() {
while (ticket>0) {
show();
}
}
使用同步方法，就不需要再创建一个对象作为同步监视器。
4.4 同步方法处理继承Thread类的线程安全问题
我们仿照实现Runnable线程安全的同步方法，
class Window4 extends Thread{
private static int ticket = 100;
public void run() {
while (ticket>0) {
show();
}
}
private synchronized void show() {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":卖票，票号为" + ticket);
ticket--;
}
}
}
但是这样是不对的，仍然是不安全的。
继承Thread类创建的线程,new 了三个线程对象，锁的对象不唯一，所以需要定义为静态方法，共用一个锁。
private static synchronized void show()
- 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
- 非静态的同步方法，同步监视器是：this
- 静态的同步方法，同步监视器是：当前类本身
4.5 线程安全的单例模式之懒汉式
package com.Liang.java1;
/**
* 使用同步机制将单例模式中的懒汉式改写为线程安全的
* Created on 2022/11/22.
*
* @author Mr Liang
*/
public class BankTest {
}
class Bank {
private Bank() {
}
private static Bank instance = null;
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.6 线程的死锁(DeadLock)问题
-
死锁
- 不同的线程分别占用对方需要的同步资源不放弃，都在等待对象放弃自己需要的同步资源，就形成了线程的死锁。
- 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。
-
解决方法
- 专门的算法、原则
- 尽量减少同步资源的定义
- 尽量避免嵌套同步
package com.Liang.java1;
/**
* 演示线程的死锁问题
* Created on 2022/11/22.
*
* @author Mr Liang
*/
public class ThreadTest {
public static void main(String[] args) {
StringBuffer s1 = new StringBuffer();
StringBuffer s2 = new StringBuffer();
new Thread() {
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);ck
}
}
}
}).start();
}
}
-
使用sleep使各自的run()方法中添加的锁阻塞一段时间，当继承Thread类创建的线程中的s1在0.1s内被阻塞时，有极大的可能去执行实现Runnnale接口创建的线程中的 s2，s2也进入阻塞状态。
-
不同的线程分别占用对方的同步资源不释放，都在等待对方释放自己需要的同步资源，从而形成了线程的死锁。
-
出现死锁后，不会出现异常，也不会出现提示，只是所有的线程都处于阻塞状态，无法继续向下执行。
-
使用同步时，要避免出现死锁。
4.7 Lock锁方式解决线程安全问题
- 从JDK 5.0 开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。
- java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问。每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应现获得Lock对象。
- ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock,可以显示加锁、释放锁。
在Runnable接口中实例化ReetrantLock
private ReentrantLock lock=new ReentrantLock(true);
对需要被同步的代码进行操作
public void run() {
while(true){
lock.lock();//调用lock()，类似于线程获取了同步监视器，下面的代码块就相当于被锁住了
try {
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 {
lock.unlock();//在finnally中进行调用unlock()方法进行解锁
}
}
}
synchronized与Lock的异同？
-
相同：二者都可以用来解决线程安全问题。
-
不同:
- synchronized机制在执行完相应的同步代码以后自动地释放同步监视器。
- Lock需要手动地启动同步(lock())，同时结束同步也需要手动的实现(unlock())。
- Lock是显式锁(手动开启和关闭锁，别忘记关闭锁)，synchronized是隐式锁。出了作用域自动释放。
- Lock只有代码块锁，synchronized有代码块锁和方法锁。
- 使用Lock锁，JVM将花费较少的时间来调度线程，性能更好。并且具有良好的扩展性(提供更多的子类)。
-
优先使用顺序
Lock —> 同步代码块(已经进入了方法体，分配了相应资源) —> 同步方法(在方法体之外)
5. 线程的通信
涉及到的三个方法:
- wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
- notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程，就唤醒优先级高的那个。
- notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
package com.Liang.java2;
/**
* 线程通信的例子
*使用两个线程打印1-100，线程1，线程2 交替打印
* 涉及到的三个方法:
* wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器
* notify():一旦执行此方法，就会唤醒被wait的一个线程，如果有多个线程，就唤醒优先级高的那个
* notifyAll():一旦执行此方法，就会唤醒所有被wait的线程
*
* 说明：
* 1.wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中，
* 2.三个方法的调用者必须是同步代码块或同步方法中的同步监视器
* 否则，会出现IllegalMonitorStateException异常
* 3.三个方法时定义在java.long.Object当中
* Created on 2022/11/23.
*
* @author Mr Liang
*/
class Number implements Runnable {
private int number = 1;
@Override
public void run() {
while (true) {
synchronized (this) {
notify();
if (number <= 100) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
System.out.println(Thread.currentThread().getName() + ":" + number);
number++;
try {//使用调用如下wait()方法的线程进入阻塞状态
wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}else
break;
}
}
}
}
public class Communication {
public static void main(String[] args) {
Number number=new Number();
Thread h1=new Thread(number);
Thread h2=new Thread(number);
h1.setName("线程一");
h2.setName("线程二");
h1.start();
h2.start();
}
}
通常情况下线程的执行没有太明显的交替现象，
在执行完number++，使用wait()方法，使线程一进入阻塞状态，线程一阻塞后，还没有结束阻塞，线程二进来之后也马上进入阻塞状态，两个都阻塞程序不再继续执行:
光使用wait()，显然是不行的。
使用notify()/notifyAll()，假设线程一抢到执行权进来之后，执行notify()，此时没什么意义，没有被阻塞的线程；线程二进来之后，执行notify,将处于阻塞状态的线程一唤醒，此时线程二拥有同步监视器，线程一无法抢占，线程二执行wait()被阻塞，一旦执行wait,会释放锁，而sleep()不会释放锁，锁释放后，线程一又获得锁，线程一进来之后将线程二又唤醒，这样就实现了线程的交替执行。
- wait(),notify(),notifyAll()三个方法必须使用在同步代码块或同步方法中。
- 三个方法的调用者必须是同步代码块或同步方法中的同步监视器，否则，会出现
IllegalMonitorStateException异常。 - 三个方法时定义在java.long.Object当中。
sleep()和wait()方法的异同
-
相同：一旦执行方法，都可以使得当前的线程进入阻塞状态。
-
不同：1）两个方法声明的位置不同：Thread类中声明sleep(),Object类声明wait()。
2）调用的范围不同： sleep()可以在任何需要的场景下调用，wait()必须使用在同步代码块和同步方法中。
3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()释放锁。
生产者/消费者问题
- 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员外取走产品，店员一次只能持有固定数量的产品，如果生产者生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
- 可能出现两个问题：
- 生产者比消费者快时，消费者会漏掉一些数据没有取到。
- 消费者比生产者快时，消费者会取相同的数据。
package com.Liang.java2;
/**
* 线程通信的应用：经典例题：生产者/消费者问题
* 生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员外取走产品，
* 店员一次只能持有固定数量(假设为20)的产品，如果生产者生产更多的产品，店员会叫生产者停一下，
* 如果店中有空位放产品了再通知生产者继续生产，如果店中没有产品了，店员会告诉消费者等一下，
* 如果店中有产品了再通知消费者来取走产品。
*
* 分析：
* 1.是否为多线程问题？是，生产者线程，消费者线程
* 2.是否有共享数据？是，店员(或产品）
* 3.如果解决线程安全问题？同步机制，三种方法
* 4.是否涉及线程的通信？是
* Created on 2022/11/24.
* @author Mr Liang
*/
class Clerk {
//生产产品
private int productnumber = 0;
public synchronized void produceproduct() {
if (productnumber < 20) {
productnumber++;
System.out.println(Thread.currentThread().getName() + ":开始生产第" + productnumber + "个产品");
notify();
} else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
// 消费产品
public synchronized void consumeproduct() {
if(productnumber>0){
System.out.println(Thread.currentThread().getName()+"开始消费第"+productnumber+"个产品");
productnumber--;
notify();
}else {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//生产者开始生产产品
class Productor implements Runnable {
private Clerk clerk;
public Productor(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + ":开始生产产品.....");
while (true) {
try {
Thread.sleep(10);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
clerk.produceproduct();
}
}
}
//消费者消费产品
class Consumer implements Runnable{
private Clerk clerk;
public Consumer(Clerk clerk){
this.clerk=clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+":开始消费产品.....");
while(true) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeproduct();
}
}
}
public class ProductTest {
public static void main(String[] args) {
Clerk c1=new Clerk();
Productor p = new Productor(c1);
Consumer c2 = new Consumer(c1);
Thread h1 = new Thread(p);
Thread h2 =new Thread(c2);
h1.setName("生产者");
h2.setName("消费者");
h1.start();
h2.start();
}
}
不妨设置Productor类中的sleep方法中的参数为10ms,Consumer类中的为100，这样产品生产的速度就会大于消费者购买产品的速度，
就会产生如下结果：
生产者生产到固定数量20时，执行wait()，进入阻塞状态，并释放锁，由消费者抢到锁，并唤醒被阻塞的线程，消费者进行消费，但是生产的的sleep时间低于消费者sleep时间，生产者更快的抢到锁去执行，所以在第20个产品上反复进行线程之间的通信。
6. JDK 5.0 新增线程创建方式
6.1 实现Callable接口
-
与使用Runnable相比，Callable功能更加强大
- 相比run()方法，可以有返回值
- 方法可以抛出异常，被外面的操作捕获，获取异常的信息
- 支持泛型的返回值
- 需要借助FutureTask类，比如获取返回
-
Future接口
- 可以对具体Runnable、Callable任务的执行结果进行取消、查询是否完成、获取结果等。
- FutureTask是Future接口的唯一的实现类。
- FutureTask同时实现了Runnable、Future接口。它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。
package com.Liang.java2;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.FutureTask;
/**
* 创建线程的方式三:实现Callable接口。——————JDK5.0新曾
*
* Created on 2022/11/24.
* @author Mr Liang
*/
//1.创建一个实现Callable的实现类
class NumThread implements Callable {
//2.实现call()方法，将此线程需要执行的操作声明在call()中
@Override
public Object call() throws Exception {
int sum = 0;
//int类型不是Object的子类，int是基本数据类型,这里int自动装箱为Integer，
for (int i = 0; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(i);
sum += i;
}
}
return sum;
}
}
public class ThreadNew {
public static void main(String[] args){
// 3.创建Callable接口实现类的对象
NumThread numThread=new NumThread();
// 4.使用Future接口，将此Callable接口实现类的对象传递到FutureTask构造器中，创建FutureTask的对象
FutureTask futureTask = new FutureTask(numThread);
// 5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
new Thread(futureTask).start();
try {
// 6.get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值
Object sum= futureTask.get();
System.out.println("总和为:"+sum);
} catch (InterruptedException e) {
throw new RuntimeException(e);
} catch (ExecutionException e) {
throw new RuntimeException(e);
}
}
}
在创建Thread对象启动线程时，调用的是FutureTask对象，查看FutureTask的定义：
FutureTask同样实现了Runnable接口。
如果想要一个call()方法的返回值，调用futureTask对象的get()方法，
try { Object sum= futureTask.get(); System.out.println("总和为:"+sum); } catch (InterruptedException e) { throw new RuntimeException(e); } catch (ExecutionException e) { throw new RuntimeException(e); }
6.2 使用线程池
- 背景:经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。
- 思路:提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。
- 好处:
- 提高响应速度(减少了创建新线程的时间)
- 降低资源消耗(重复利用线程池中线程，不需要每次都创建)
- 便于线程管理
线程池相关API
-
JDK 5.0提供了线程池相关API:ExecutorService和Executors。
-
ExecutorService:真正的线程池接口。常见子类ThreadPoolExecutor。
void execute(Runnable command):执行任务/命令，没有返回值，一般用来执行Runnable。<T>Future<T>submit(Callable<T>task):执行任务，有返回值，一般又来执行Callable。void shutdown():关闭连接池。
-
Executors: 工具类、线程池的工厂类，用于创建并返回不同类型的线程池。
Executors.newCachedThreadPool():创建一个可根据需要创建新线程的线程池。Executors.newFixedThreadPool(n):创建一个可重用固定线程数的线程池。Executors.newSingleThreadExecutor():创建一个只有一个线程的线程池。Executors.newScheduledThreadPool(n):创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
package com.Liang.java2;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* 创建线程的方式四，使用线程池
* Created on 2022/11/25.
*
* @author Mr Liang
*/
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) {
// 提供指定数量的线程池
ExecutorService service = Executors.newFixedThreadPool(10);
// 执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
service.execute(new NumberThread());//适合适用于Runnable
service.execute(new NumberThread1());
// service.submit(Callable callable);适合适用于Callable
service.shutdown();//关闭线程池
}
}
线程池便于线程管理，可以设置一些属性：
- corePoolsize:核心池的大小
- maximumPoolSize:最大线程数
- keepAliveTime:线程没有任务时最多保持多长时间后会终止
接口中的属性为常量，在ExecutorService接口中不能设置这些属性，查看接口对象的实现类：
System.out.println(service.getClass());
查看ThreadPoolExecutor的定义：
查看AbstractExecutorService:
可以对Service接口对象强转为ThreadPoolExecutor类，
ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
这样就可以调用方法设置属性，
service1.setCorePoolSize();
service1.setMaximumPoolSize();
service1.setKeepAliveTime();
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
