程序（program）是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程（process）是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程，有它自身的产生、存在和消亡的进程，即生命周期。
线程（thread）是程序内部的一条执行路径。
单核 CPU 和 多核 CPU：
并行和并发：
使用多线程的优点：
何时需要多线程：
Java 语言的 JVM 允许程序运行多个线程，它通过 java.lang.Thread 类来体现。这个类的特征：
多线程的创建方式一：继承 Thread 类
package com.parzulpan.java;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 多线程的创建方式一：继承 Thread 类
* 创建两个子线程，让其中一个线程输出1-1000之间的偶数，另一个线程输出1-1000之间的奇数。
*/
public class ThreadTest {
public static void main(String[] args) {
MyThread myThread = new MyThread("偶数线程",0);
MyThread myThread1 = new MyThread("奇数线程",1);
myThread.start();
myThread1.start();
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println("主线程" + Thread.currentThread().getName() + " " + i);
}
}
}
}
class MyThread extends Thread {
private int flag;
private String msg;
public MyThread(String msg, int flag) {
super();
this.msg = msg;
this.flag = flag;
}
@Override
public void run() {
for (int i = 0; i < 1000; i++) {
if (i % 2 == flag) {
System.out.println(msg + Thread.currentThread().getName() + " " + i);
}
}
}
}
创建方式一的注意问题：
Thread 类的有关方法：
线程的调度：
线程的优先级：
多线程的创建方式二：实现 Runnable 接口
package com.parzulpan.java;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 多线程的创建方式二：实现 Runnable 接口
*/
public class ThreadTest1 {
public static void main(String[] args) {
// 3.
MyThreadA myThreadA = new MyThreadA();
// 4.
Thread thread1 = new Thread(myThreadA);
// 5.
thread1.setName("线程1");
thread1.start();
Thread thread2 = new Thread(myThreadA);
// 5.
thread2.setName("线程2");
thread2.start();
}
}
// 1.
class MyThreadA implements Runnable {
// 2.
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
继承方式和实现方式的区别和联系：
线程的分类：一种是守护线程，一种是用户线程。
JDK 中用 Thread.State 类定义了线程的几种状态。
线程的一个完整生命周期中通常要经历五个状态：
线程的生命周期：
多线程会出现安全问题。
问题的原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。
解决方法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不可以参与执行。
同步机制 是 Java 对于多线程的安全问题提供的专业解决方式。
方式一：同步代码块
synchronixed(同步监视器) {
// 需要被同步的代码
}
// 说明：操作共享数据的代码，即为需要被同步的代码。
// 共享数据即为多个线程共同操作的数据。
// 同步监视器，俗称锁。任何一个类的对象，都可以充当锁。要求多个线程必须要公用同一把锁。
package com.parzulpan.java;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 多线程的创建方式二：实现 Runnable 接口
* 线程的同步 - 同步代码块，解决线程同步（安全）的问题
*/
public class WindowTest2 {
public static void main(String[] args) {
Window2 window2 = new Window2();
Thread thread1 = new Thread(window2);
thread1.setName("窗口1");
Thread thread2 = new Thread(window2);
thread2.setName("窗口2");
Thread thread3 = new Thread(window2);
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
class Window2 implements Runnable {
private int ticket = 100;
private final Object object = new Object();
@Override
public void run() {
while (true) {
// 正确
// synchronized (this) {
// 正确
synchronized (object) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
--ticket;
} else {
break;
}
}
}
}
}
package com.parzulpan.java;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 多线程的创建方式一：继承 Thread 类
* 线程的同步 - 同步代码块，解决线程同步（安全）的问题
*/
public class WindowTest3 {
public static void main(String[] args) {
Window3 window1 = new Window3("窗口1");
Window3 window2 = new Window3("窗口2");
Window3 window3 = new Window3("窗口3");
window1.start();
window2.start();
window3.start();
}
}
class Window3 extends Thread {
// static
private static int ticket = 100;
private static Object object = new Object();
Window3(String name) {
super(name);
}
@Override
public void run() {
super.run();
while (true) {
// 错误，因为 this 代表 window1 window2 window3 三个对象
// synchronized (this) {
// 正确，因为 Class clazz = Window3.class，Window3 只会加载一次
synchronized (Window3.class) {
// 正确
// synchronized (object) {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(getName() + "：卖票，票号为：" + ticket);
--ticket;
} else {
break;
}
}
}
}
}
同步的方式，解决了线程的安全问题。但是操作同步代码时，只能有一个线程参与，其他线程等待，相当于一个单线程的过程，效率低。
方法二：同步方法
public synchronized void show (String name){
//
}
package com.parzulpan.java;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 多线程的创建方式二：实现 Runnable 接口
* 线程的同步 - 同步方法，解决线程同步（安全）的问题
*/
public class WindowTest4 {
public static void main(String[] args) {
Window4 window4 = new Window4();
Thread thread1 = new Thread(window4);
thread1.setName("窗口1");
Thread thread2 = new Thread(window4);
thread2.setName("窗口2");
Thread thread3 = new Thread(window4);
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
class Window4 implements Runnable {
private int ticket = 100;
@Override
public void run() { // 同步监视器为 this
while (true) {
show();
}
}
private synchronized void show() {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
--ticket;
}
}
}
package com.parzulpan.java;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 多线程的创建方式一：继承 Thread 类
* 线程的同步 - 同步方法，解决线程同步（安全）的问题
*/
public class WindowTest5 {
public static void main(String[] args) {
Window5 window1 = new Window5("窗口1");
Window5 window2 = new Window5("窗口2");
Window5 window3 = new Window5("窗口3");
window1.start();
window2.start();
window3.start();
}
}
class Window5 extends Thread {
// static
private static int ticket = 100;
Window5(String name) {
super(name);
}
@Override
public void run() {
super.run();
while (true) {
show();
}
}
private static synchronized void show() { // 正确，同步监视器为 Window5.class
// private synchronized void show() { // 错误，同步监视器为 window1 window2 window3
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
--ticket;
}
}
}
线程的死锁问题：
方法三：Lock 锁，JDK5新增
java.util.concurrent.locks.Lock 接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对 Lock 对象加锁，线程开始访问共享资源之前应先获得 Lock 对象。ReentrantLock 类实现了 Lock ，它拥有与 synchronized 相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是 ReentrantLock，可以显式加锁、释放锁。
package com.parzulpan.java;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 方法二：Lock 锁，JDK5新增
*/
public class LockTest {
public static void main(String[] args) {
Window6 window1 = new Window6();
Thread thread1 = new Thread(window1);
thread1.setName("窗口1");
Thread thread2 = new Thread(window1);
thread2.setName("窗口2");
Thread thread3 = new Thread(window1);
thread3.setName("窗口3");
thread1.start();
thread2.start();
thread3.start();
}
}
class Window6 implements Runnable {
private int ticket = 100;
private final ReentrantLock lock = new ReentrantLock(true); // fair 为 true 代表公平锁，为 false 代表不公平锁，默认为 false
@Override
public void run() {
while (true) {
lock.lock();
try {
if (ticket > 0) {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
--ticket;
} else {
break;
}
} finally {
lock.unlock();
}
}
}
}
synchronized 与 Lock 的对比
优先使用顺序：Lock -> 同步代码块（已经进入了方法体，分配了相应资源）-> 同步方法（在方法体之外）
线程通信的有关方法：
注意：
package com.parzulpan.java;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 线程通信的例子：使用两个线程打印 1-100。线程1, 线程2 交替打印
*/
public class CommunicationTest {
public static void main(String[] args) {
Communication communication = new Communication();
Thread thread1 = new Thread(communication);
Thread thread2 = new Thread(communication);
thread1.setName("线程1");
thread2.setName("线程2");
thread1.start();
thread2.start();
}
}
class Communication implements Runnable {
private int number = 1;
@Override
public void run() {
while (true) {
synchronized (this) {
notify();
if (number <= 100) {
System.out.println(Thread.currentThread().getName() + ":" + number++);
} else {
break;
}
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
多线程的创建方式三：实现 Callable 接口
与使用 Runnable 相比， Callable 功能更强大些：
Future 接口：
package com.parzulpan.java;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 多线程的创建方式三：实现 Callable 接口
*/
public class NumberThreadTest {
public static void main(String[] args) {
// 3. 创建 Callable 接口实现类的对象
NumberThread numberThread = new NumberThread();
// 4. 将此 Callable 接口实现类的对象传递到 FutureTask 构造器中，创建 FutureTask 对象
// FutureTask futureTask = new FutureTask(numberThread);
FutureTask<Integer> futureTask = new FutureTask<Integer>(numberThread);
// 5. 将 FutureTask 对象传递到 Thread 构造器中，创建 Thread 对象，并 start() 启动
Thread thread = new Thread(futureTask);
thread.start();
try {
// 6. 获取 Callable 中 call 方法的返回值
// get() 返回值 即为 FutureTask 构造器参数 Callable 实现类重写的 call() 返回值
// Object sum = futureTask.get();
Integer sum = futureTask.get();
System.out.println("偶数和为：" + sum);
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
}
}
}
// 1. 创建一个实现 Callable 的实现类
class NumberThread implements Callable<Integer> {
// 2. 实现 call() ，将此线程需要执行的操作声明在 call() 中
@Override
public Integer 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;
}
}
多线程的创建方式四：使用线程池
重要！！！
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，
对性能影响很大。
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。
好处：
JDK5 起提供了线程池相关 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.parzulpan.java;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.ThreadPoolExecutor;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 多线程的创建方式四：使用线程池
*/
public class ThreadPool {
public static void main(String[] args) {
ExecutorService executorService = Executors.newFixedThreadPool(10);
ThreadPoolExecutor threadPoolExecutor = (ThreadPoolExecutor) executorService;
threadPoolExecutor.setCorePoolSize(15);
executorService.execute(new OddNumThread());
executorService.execute(new EvenNumThread());
executorService.execute(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
});
executorService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
for (int i = 0; i < 100; i++) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
return null;
}
});
executorService.shutdown();
}
}
class OddNumThread 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 EvenNumThread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ": " + i);
}
}
}
}
模拟火车站售票程序，开启三个窗口售票。
[多线程的创建方式二：实现 Runnable 接口]https://github.com/parzulpan/demo/tree/main/JavaBasis/src/code/ch06/src/com/parzulpan/java/WindowTest1.java)
银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
package com.parzulpan.exer;
import java.util.concurrent.locks.ReentrantLock;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 银行有一个账户。
* 银行有一个账户。有两个储户分别向同一个账户存3000元，每次存1000，存3次。每次存完打印账户余额。
* 分析：
* 1. 是否是多线程问题？ 是，两个储户线程
* 2. 是否有共享数据？ 有，账户（账户余额）
* 3. 该程序是否有安全问题，如果有，如何解决？ 有，使用同步机制，有三种方式。
*/
public class AccountTest {
public static void main(String[] args) {
Account account = new Account(0);
// Customer customer1 = new Customer(account);
// Customer customer2 = new Customer(account);
// customer1.setName("甲");
// customer2.setName("乙");
// customer1.start();
// customer2.start();
CustomerA customerA1 = new CustomerA(account);
Thread thread1 = new Thread(customerA1);
Thread thread2 = new Thread(customerA1);
thread1.setName("甲");
thread2.setName("乙");
thread1.start();
thread2.start();
}
}
class Account {
private double balance;
private static final ReentrantLock lock = new ReentrantLock(true); // 如果有多个 Account，这里的 lock 最好为 static
public Account(double balance) {
this.balance = balance;
}
// 存钱，线程不同步（安全）
public void deposit(double amt) {
if (amt > 0) {
this.balance += amt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 存钱成功。余额为：" + this.balance);
}
}
// 线程的同步 - 同步代码块，解决线程同步（安全）的问题
public void deposit1(double amt) {
synchronized (this) { // 同步监视器为 this
if (amt > 0) {
this.balance += amt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 存钱成功。余额为：" + this.balance);
}
}
}
// 线程的同步 - 同步方法，解决线程同步（安全）的问题
public synchronized void deposit2(double amt) { // 同步监视器为 this，此时为一个 Account。
// 注意：在继承 Thread 类创建多线程时，要慎用 this
if (amt > 0) {
this.balance += amt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 存钱成功。余额为：" + this.balance);
}
}
// 线程的同步 - Lock，解决线程同步（安全）的问题
public void deposit3(double amt) {
lock.lock();
try {
if (amt > 0) {
this.balance += amt;
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ": 存钱成功。余额为：" + this.balance);
}
} finally {
lock.unlock();
}
}
}
// 多线程的创建方式一：继承 Thread 类
class Customer extends Thread {
private Account account;
public Customer(Account account) {
this.account = account;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
// account.deposit(1000);
// account.deposit1(1000);
// account.deposit2(1000);
account.deposit3(1000);
}
}
}
// 多线程的创建方式二：实现 Runnable 接口
class CustomerA implements Runnable {
private Account account;
public CustomerA(Account account) {
this.account = account;
}
@Override
public void run() {
for (int i = 0; i < 3; i++) {
// account.deposit(1000);
// account.deposit1(1000);
// account.deposit2(1000);
account.deposit3(1000);
}
}
}
sleep() 和 wait() 的异同？
相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
不同点：1. 声明的位置不同：sleep() 声明在 Thread 类中。wait() 声明在 Object 类中。2. 调用的要求不同：sleep() 可以在任何场景下调用。wait() 必须在 同步代码块或同步方法中调用。3. 释放同步监视器不同：如果都在同步代码块或同步方法中调用，sleep() 不会释放锁，wait() 会释放锁。
生产者/消费者问题？
package com.parzulpan.exer;
/**
* @Author : parzulpan
* @Time : 2020-11-23
* @Desc : 线程通信应用：生产者/消费者问题
* 生产者(Producer)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），
* 如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；
* 如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。
* 1. 是否是多线程问题？ 是，生产者线程、消费者线程
* 2. 是否共享数据？ 是，店员（产品）
* 3. 是否有安全问题，如果有，如何解决？ 有，使用同步机制，有三种方式。
* 4. 是否有线程通信？是
*/
public class ProductTest {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer producer = new Producer(clerk);
Consumer consumer = new Consumer(clerk);
Thread thread1 = new Thread(producer);
Thread thread2 = new Thread(consumer);
Thread thread3 = new Thread(consumer);
thread1.setName("生产者");
thread2.setName("消费者1");
thread3.setName("消费者2");
thread1.start();
thread2.start();
thread3.start();
}
}
// 售货员
class Clerk {
private int product;
public synchronized void addProduct() {
if (product >= 20) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
++product;
System.out.println(Thread.currentThread().getName() + " 生产了第 " + product + " 个产品");
notifyAll();
}
}
public synchronized void removeProduct() {
if (product <= 0) {
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
} else {
System.out.println(Thread.currentThread().getName() + " 消费了第 " + product + " 个产品");
--product;
notifyAll();
}
}
}
// 生产者
class Producer implements Runnable {
private Clerk clerk;
Producer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 开始生产产品");
while (true) {
try {
Thread.sleep((long) (Math.random() * 500));
} catch (InterruptedException e) {
e.printStackTrace();
}
this.clerk.addProduct();
}
}
}
// 消费者
class Consumer implements Runnable {
private Clerk clerk;
Consumer(Clerk clerk) {
this.clerk = clerk;
}
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + " 开始消费产品");
while (true) {
try {
Thread.sleep((long) (Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
this.clerk.removeProduct();
}
}
}
原文：https://www.cnblogs.com/parzulpan/p/14131646.html