一.程序、进程、线程的概念
基本概念
程序（program）是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。
进程（process）是程序的一次执行过程，或是正在运行的一个程序。动态过程：有它自身的产生、存在和消亡的过程。如：运行中的QQ，运行中的MP3播放器；程序是静态的，进程是动态的。
线程（thread）进程可进一步细化为线程，是一个程序内部的一条执行路径。若一个程序可同一时间执行多个线程，就是支持多线程的。
何时需要多线程：程序需要同时执行两个或多个任务；程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等:需要一些后台运行的程序时。
二.Java中多线程的创建和使用
多线程的创建和启动
Java语言的JVM允许程序运行多个线程，它通过java.lang.Thread类来实现。
Thread类的特性：每个线程都是通过某个特定的Thread对象的run（）方法来完成操作的，经常把run（）方法的主体称为线程体。通过该Thread对象的start（）方法来调用这个线程。
背景：只使用单个线程完成多个任务（调用多个方法），肯定比多个线程来完成用的时间更短，为何仍然需要多线程呢？
多线程程序的优点：提高应用程序的响应。对图形化界面更有意义，可增强用户体验。提高计算机系统CPU的利用率。改善程序结构，将既长又复杂的进程分为多个程序，独立运行，利于理解和修改。
Java中的线程分为两类：一种是守护线程，一种是用户线程。它们在几乎每个方面都是相同的，唯一的区别是判断JVM何时离开；守护线程是用来服务用户线程的，可以把start（）方法前调用thread.setDaemon（true）可以把用户线程变成一个守护线程；Java垃圾回收就是一个典型的守护线程；若JVM中都是守护线程，当前JVM将退出。
继承Thread类与实现Runnable接口
继承Thread类
//1.创建一个继承于Thread的子类
class SubThread extends Thread{
//2.重写Thread类的run()方法.方法内实现此子线程要完成的功能
public void run(){
for(int i = 1;i <= 100;i++){
System.out.println(Thread.currentThread().getName() +":" + i);
}
}
}
public class TestThread {
public static void main(String[] args) {
//3.创建子类的对象
SubThread st1 = new SubThread();
SubThread st2 = new SubThread();
//4.调用线程的start()：启动此线程；调用相应的run()方法
//一个线程只能够执行一次start()
//不能通过Thread实现类对象的run()去启动一个线程
st1.start();
st2.start();
for(int i = 1;i <= 100;i++){
System.out.println(Thread.currentThread().getName() +":" + i);
}
}
}
实现Runnable接口
//1.创建一个实现了Runnable接口的类
class PrintNum implements Runnable {
//2.实现接口的抽象方法
// 子线程执行的代码
public void run() {
for (int i = 1; i <= 100; i++) {
if (i % 2 == 0) {
System.out.println(Thread.currentThread().getName() + ":" + i);
}
}
}
}
public class TestThread {
public static void main(String[] args) {
//3.创建一个Runnable接口实现类的对象
//要想启动一个多线程，必须调用start()
PrintNum p = new PrintNum();
//4.将此对象作为形参传递给Thread类的构造器中，创建Thread类的对象，此对象即为一个线程
Thread t = new Thread(p);
//5.调用start()方法：启动线程并执行run()
t.start();
//启动线程；执行Thread对象生成时构造器形参的对象的run()方法。
//再创建一个线程
Thread tt = new Thread(p);
tt.start();
}
}
继承的方式 vs 实现的方式：联系，public class Thread implements Runnable；哪个方式好？实现的方式优于继承的方式；为什么？①避免了java单继承的局限性②如果多个线程要操作同一份资源（或数据），更适合使用实现的方式。
Thread类的主要方法
1.start()：启动线程并执行相应的run()方法
2.run():子线程要执行的代码放入run()方法中
3.currentThread()：静态的，调取当前的线程
4.getName():获取此线程的名字
5.setName():设置此线程的名字
6.yield():调用此方法的线程释放当前CPU的执行权
7.join():在A线程中调用B线程的join()方法，表示：当执行到此方法，A线程停止执行，直至B线程执行完毕，A线程再接着join()之后的代码执行
8.isAlive():判断当前线程是否还存活
9.sleep(long l):显式的让当前线程睡眠l毫秒
10.线程通信：wait() notify() notifyAll()
线程的调度与设置优先级
调度策略：时间片、抢占式（高优先级的线程抢占CPU）。
Java的调度方法：同优先级线程组成先进先出队列（先到先服务），使用时间片策略。对高优先级，使用优先调度的抢占式策略。
线程的优先级控制MAX_PRIORITY(10);MIN_PRIORITY(1);NORM_PRIORITY(5)。
设置线程的优先级涉及的方法, 线程创建时继承父线程的优先级：getPriority()，返回线程优先值，是一个静态的方法；setPriority(int newPriority)，改变线程的优先级。
三.线程的生命周期
四.线程的同步
线程的安全性问题
如：打印车票时，会出现重票，错票。
线程安全性问题存在的原因？由于一个线程在操作共享数据的过程中，未执行完的情况下，另外的线程参与进来，导致共享数据存在了安全问题。
如何解决线程的安全问题？必须让一个线程操作共享数据完毕以后，其他线程才有机会参与共享数据的操作。
java如何实现线程的安全：线程的同步机制。
方式一：同步代码块
synchronized(同步监视器){
//需要被同步的代码块（即为操作共享数据的代码）
}
共享数据：多个线程共同操作的同一个数据(变量)。
同步监视器：由一个类的对象来充当。哪个线程获取此监视器，谁就执行大括号里被同步的代码。俗称：锁。
要求：所有的线程必须共用同一把锁！可以用对象来充当锁，但必须声明成成员变量，如果声明为局部变量，相当于每个线程都有各自的锁！在实现的方式中，考虑同步的话，可以使用this来充当锁，但是在继承的方式中，慎用this，因为继承中每个线程都各自都各自的锁！如果继承中想要实现同步可使用同步代码块，用静态的对象来充当锁！
class Window implements Runnable {
int ticket = 100;
public void run() {
while (true) {
synchronized (this) {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName()
+ "售票，票号为：" + ticket--);
}
}
}
}
}
方式二：同步方法
public synchronized void show(){}
将操作共享数据的方法声明为synchronized。即此方法为同步方法，能够保证当其中一个线程执行。此方法时，其它线程在外等待直至此线程执行完此方法。
同步方法的锁：this,所以只能用在以实现的方式创建多线程上，继承的方式不可以
class Window implements Runnable {
int ticket = 100;
public synchronized void run() {
while (true) {
show();
}
}
public synchronized void show() {
if (ticket > 0) {
System.out.println(Thread.currentThread().getName() + "售票，票号为："
+ ticket--);
}
}
}
方式三：锁（Jdk5.0之后加入的）
关于懒汉式的线程安全问题：使用同步机制。
class Singleton {
private Singleton() {
}
private static Singleton instance = null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
五.线程的死锁问题
死锁：不同的线程分别占用对方需要同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。
public class TestDeadLock {
static StringBuffer sb1 = new StringBuffer();
static StringBuffer sb2 = new StringBuffer();
public static void main(String[] args) {
new Thread() {
public void run() {
synchronized (sb1) {
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sb1.append("A");
synchronized (sb2) {
sb2.append("B");
System.out.println(sb1);
System.out.println(sb2);
}
}
}
}.start();
new Thread() {
public void run() {
synchronized (sb2) {
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sb1.append("C");
synchronized (sb1) {
sb2.append("D");
System.out.println(sb1);
System.out.println(sb2);
}
}
}
}.start();
}
}
解决办法
专门的算法、原则，尽量减少同步资源的定义。
生产者/消费者问题
生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品， 店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下， 如果店中有产品了再通知消费者来取走产品。
分析：是否涉及到多线程的问题？是！生产者、消费者；是否涉及到共享数据？有！考虑线程的安全；；此共享数据是谁？即为产品的数量；是否涉及到线程的通信呢？存在这生产者与消费者的通信。
class Clerk{//店员
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 consumeProduct(){//消费产品
if(product <= 0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}else{
System.out.println(Thread.currentThread().getName() + ":消费了第" + product + "个产品");
product--;
notifyAll();
}
}
}
class Producer implements Runnable{//生产者
Clerk clerk;
public Producer(Clerk clerk){
this.clerk = clerk;
}
public void run(){
System.out.println("生产者开始生产产品");
while(true){
try {
Thread.currentThread().sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.addProduct();
}
}
}
class Consumer implements Runnable{//消费者
Clerk clerk;
public Consumer(Clerk clerk){
this.clerk = clerk;
}
public void run(){
System.out.println("消费者消费产品");
while(true){
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
clerk.consumeProduct();
}
}
}
public class TestProduceConsume {
public static void main(String[] args) {
Clerk clerk = new Clerk();
Producer p1 = new Producer(clerk);
Consumer c1 = new Consumer(clerk);
Thread t1 = new Thread(p1);//一个生产者的线程
Thread t3 = new Thread(p1);
Thread t2 = new Thread(c1);//一个消费者的线程
t1.setName("生产者1");
t2.setName("消费者1");
t3.setName("生产者2");
t1.start();
t2.start();
t3.start();
}
}
关于锁的操作
释放锁的操作
当前线程的同步方法、同步代码块执行结束。当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束。当前线程在同步带买块、同步方法中执行了线程对象的wait（）fangf，当前线程暂停，并释放锁。
不会释放锁的操作
线程执行同步代码块或同步方法时，程序调用Thread.sleep（）、Thread.yield（）方法暂停当前你线程的执行。线程执行同步代码块时，其他线程调用了该线程的suspend（）方法将该线程挂起，该线程不会释放锁（同步监视器）。应该尽量避免使用suspend（）和resume（）控制线程。
五.线程的通信
wait（）和notify（）和notifyAll（）
wait（）：令当前线程挂起并放弃CPU、同步资源，使别的线程可访问并修改共享资源，而当前线程排队等候再次对资源的访问。
notify（）：唤醒正在排队等待同步资源的线程中优先级最高者结束等待。
notifyAll（）：唤醒正在排队等待资源的所有线程结束等待。
Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用，否则会报java.lang.IllegalMonitorStateException异常。
代码：使用两个线程打印 1-100. 线程1, 线程2 交替打印
class PrintNum implements Runnable {
int num = 1;
Object obj = new Object();
public void run() {
while (true) {
synchronized (obj) {
obj.notify();
if (num <= 100) {
try {
Thread.currentThread().sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + ":"
+ num);
num++;
} else {
break;
}
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
public class TestCommunication {
public static void main(String[] args) {
PrintNum p = new PrintNum();
Thread t1 = new Thread(p);
Thread t2 = new Thread(p);
t1.setName("甲");
t2.setName("乙");
t1.start();
t2.start();
}
}
来源：CSDN
作者：Smirk513
链接：https://blog.csdn.net/weixin_44145972/article/details/88926755