概念
进程：是具有一定独立功能的程序、它是系统进行资源分配和调度的一个独立单位，重点在系统调度和单独的单位，也就是说进程是可以独 立运行的一段程序。
线程：线程进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。在运行时，只是暂用一些计数器、寄存器和栈 。
区别
- 调度：线程作为调度和分配的基本单位，进程作为拥有资源的基本单位。
- 并发性：不仅进程之间可以并发执行，同一个进程的多个线程之间也可以并发执行。
- 拥有资源：进程是拥有资源的一个独立单位，线程不拥有系统资源，但可以访问隶属于进程的资源
线程创建
三种方式
- Thread类 继承 重点
- Runnable接口 实现 重点
- Callable 接口 实现 了解
Thread类
1、自定义线程类继承Thread类
2、重写run()方法，编写线程执行体
3、创建线程对象，调用start()方法启动线程
例子：
package com.sun.test;
//继承Thread类，重写run()方法，调用start()开启线程
public class ThreadTest1 extends Thread{
@Override
public void run(){
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("run方法线程体输出"+i);
}
}
public static void main(String[] args) {
//main主线程
//创建一个线程对象
ThreadTest1 threadTest1 = new ThreadTest1();
//开启线程
threadTest1.start();
for (int i = 0; i < 1000; i++) {
System.out.println("main方法线程体输出"+i);
}
}
}
案例：
package com.sun.test;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//Tread案例：实现多线程同步下载图片
public class ThreadTest2 extends Thread{
private String url;
private String fileName;
public ThreadTest2(String url,String fileName){
this.fileName = fileName;
this.url = url;
}
@Override
public void run() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url,fileName);
System.out.println(fileName+"文件下载了");
}
public static void main(String[] args) {
ThreadTest2 t1 = new ThreadTest2("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image1.jpg");
ThreadTest2 t2 = new ThreadTest2("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image2.jpg");
ThreadTest2 t3 = new ThreadTest2("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image3.jpg");
//启动三个线程 t1->t2->t3
t1.start();
t2.start();
t3.start();
}
}
//下载器
class WebDownloader{
public void downloader(String url,String fileName){
try {
FileUtils.copyURLToFile(new URL(url),new File(fileName));
} catch (IOException e) {
e.printStackTrace();
}
}
}
Runnable接口（推荐）
1、定义一个Runnable类实现Runnable接口
2、实现run()方法，编写执行体
3、创建线程对象，调用start()方法启动线程
例子：
package com.sun.test;
//实现Runnable接口，重写run()方法，执行线程需要Runnable接口实现类，调用start()方法
public class ThreadTest3 implements Runnable{
@Override
public void run(){
//run方法线程体
for (int i = 0; i < 20; i++) {
System.out.println("run方法线程体输出"+i);
}
}
public static void main(String[] args) {
//创建Runnable接口实现类对象
ThreadTest3 threadTest3 = new ThreadTest3();
//创建一个线程对象
new Thread(threadTest3).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main方法线程体输出"+i);
}
}
}
案例：
package com.sun.test;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
//Runnable案例：实现多线程同步下载图片
public class ThreadTest2 implements Runnable{
private String url;
private String fileName;
public ThreadTest2(String url,String fileName){
this.fileName = fileName;
this.url = url;
}
@Override
public void run() {
WebDownloader webDownloader = new WebDownloader();
webDownloader.downloader(url,fileName);
System.out.println(fileName+"文件下载了");
}
public static void main(String[] args) {
ThreadTest2 t1 = new ThreadTest2("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image1.jpg");
ThreadTest2 t2 = new ThreadTest2("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image2.jpg");
ThreadTest2 t3 = new ThreadTest2("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image3.jpg");
//启动三个线程 t1->t2->t3
new Thread(t1).start();
new Thread(t2).start();
new Thread(t3).start();
}
}
//下载器
class WebDownloader{
public void downloader(String url,String fileName){
try {
FileUtils.copyURLToFile(new URL(url),new File(fileName));
} catch (IOException e) {
e.printStackTrace();
}
}
}
推荐使用通过实现Runnable接口来创建线程：避免单继承局限性，灵活方便，方便同一个对象被多个线程使用
例子：
package com.sun.test;
//多个线程同时操作同一个对象
public class ThreadTest4 implements Runnable {
private int ticketNum = 10;
@Override
public void run(){
while(true){
if(ticketNum<=0){
break;
}
try {
//模拟延时，为了好看结果
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"买到了第"+ticketNum--+"张票");
}
}
public static void main(String[] args) {
ThreadTest4 threadTest4 = new ThreadTest4();
new Thread(threadTest4,"小黑").start();
new Thread(threadTest4,"小红").start();
new Thread(threadTest4,"小白").start();
}
}
这样写会有一个问题：不同的人会买到同一张票。
在这里插入图片描述
多线程操作同一个资源的情况下，线程不安全。
Callable接口
1、实现Callable接口，需要返回值类型
2、重写call()方法，需要抛出异常
3、创建目标对象
4、创建执行服务：ExecutorService ser = Executors.newFixedThreadPool(1);
5、提交执行：Future
6、获取结果：boolean r1 = result1.get();
7、关闭服务：ser.shutdownNow();
例子：
package com.sun.test;
import org.apache.commons.io.FileUtils;
import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.concurrent.*;
//Callable接口创建线程
public class CallableTest implements Callable {
private String url;
private String fileName;
public CallableTest(String url,String fileName){
this.fileName = fileName;
this.url = url;
}
@Override
public Boolean call() {
WebDownloader1 webDownloader1 = new WebDownloader1();
webDownloader1.downloader(url,fileName);
System.out.println(fileName+"文件下载了");
return true;
}
public static void main(String[] args) {
CallableTest t1 = new CallableTest("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image1.jpg");
CallableTest t2 = new CallableTest("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image2.jpg");
CallableTest t3 = new CallableTest("https://www.ncwu.edu.cn/upload/images/2020/2/t_4d876cff7076a6e2.jpg","image3.jpg");
//创建执行服务
ExecutorService ser = Executors.newFixedThreadPool(3);
//提交执行
Future r1 = ser.submit(t1);
Future r2 = ser.submit(t2);
Future r3 = ser.submit(t3);
//获取结果
try {
boolean result1 = r1.get();
boolean result2 = r2.get();
boolean result3 = r3.get();
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
//关闭服务
ser.shutdownNow();
}
}
//下载器
class WebDownloader1{
public void downloader(String url,String fileName){
try {
FileUtils.copyURLToFile(new URL(url),new File(fileName));
} catch (IOException e) {
e.printStackTrace();
}
}
}
线程状态
进程状态图：
在这里插入图片描述
-
新建状态:
使用 new 关键字和 Thread 类或其子类建立一个线程对象后，该线程对象就处于新建状态。它保持这个状态直到程序 start() 这个线程。
-
就绪状态:
当线程对象调用了start()方法之后，该线程就进入就绪状态。就绪状态的线程处于就绪队列中，要等待JVM里线程调度器的调度。
-
运行状态:
如果就绪状态的线程获取 CPU 资源，就可以执行 run()，此时线程便处于运行状态。处于运行状态的线程最为复杂，它可以变为阻塞状态、就绪状态和死亡状态。
-
阻塞状态:
如果一个线程执行了sleep（睡眠）、suspend（挂起）等方法，失去所占用资源之后，该线程就从运行状态进入阻塞状态。在睡眠时间已到或获得设备资源后可以重新进入就绪状态。可以分为三种：
- 等待阻塞：运行状态中的线程执行 wait() 方法，使线程进入到等待阻塞状态。
- 同步阻塞：线程在获取 synchronized 同步锁失败(因为同步锁被其他线程占用)。
- 其他阻塞：通过调用线程的 sleep() 或 join() 发出了 I/O 请求时，线程就会进入到阻塞状态。当sleep() 状态超时，join() 等待线程终止或超时，或者 I/O 处理完毕，线程重新转入就绪状态。
-
死亡状态:
一个运行状态的线程完成任务或者其他终止条件发生时，该线程就切换到终止状态。
线程方法
- setPriority(int newPriority)：更改线程优先级
- static void sleep(long millis)：在指定的毫秒数内让当前正在执行的线程休眠
- void join()：等待该线程终止
- static void yield()：暂停当前正在执行的线程对象，并执行其他线程
- void interrupt()：中断线程，不推荐用此方法
- boolean isAlive()：测试线程是否处于活动状态
线程停止
- 不推荐使用JDK提供的stop()、destroy()方法
- 推荐线程自己停止下来
- 建议使用一个标志位进行终止变量，当flag=false，则表示终止线程
例子：
package com.sun.test;
public class TestStop implements Runnable {
//设置一个标志位
private boolean flag = true;
@Override
public void run() {
int i = 0;
while(flag){
System.out.println("run"+i++);
}
}
//编写一个公开的方法停止线程
public void myStop(){
this.flag = false;
}
public static void main(String[] args) {
TestStop testStop = new TestStop();
new Thread(testStop).start();
for (int i = 0; i < 1000; i++) {
System.out.println("main"+i);
if(i==800){
//让线程停止
testStop.myStop();
System.out.println("线程停止了");
}
}
}
}
线程休眠
- sleep(时间)指定当前线程阻塞的毫秒数
- sleep存在异常InterruptedException
- sleep时间达到后线程进入就绪状态
- sleep可以模拟网络延时、倒计时等
- 每一个对象都有一个锁，sleep不会释放锁
例子：
package com.sun.test;
//模拟倒计时
public class TestSleep {
public void countdown() throws InterruptedException {
int count = 10;
while(true){
Thread.sleep(1000);
System.out.println(count--);
if(count<=0){
break;
}
}
}
public static void main(String[] args) {
TestSleep testSleep = new TestSleep();
try {
testSleep.countdown();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
线程礼让
- 礼让线程，让当前正在执行的线程暂停，但不阻塞
- 将线程从运行状态转换为就绪状态
- 让CPU重新调度，礼让不一定成功，有可能转为就绪态了又被重新调度了
例子：
package com.sun.test;
public class TestYield {
public static void main(String[] args) {
MyYield myYield = new MyYield();
new Thread(myYield,"a").start();
new Thread(myYield,"b").start();
}
}
class MyYield implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"线程执行");
//礼让
Thread.yield();
System.out.println(Thread.currentThread().getName()+"线程结束");
}
}
线程强制执行
- Join合并线程，待此线程执行完成后在执行其他线程，其他线程阻塞
例子：
package com.sun.test;
public class TestJoin implements Runnable{
@Override
public void run() {
for (int i = 0; i < 500; i++) {
System.out.println("vip线程执行"+i);
}
}
public static void main(String[] args) throws InterruptedException {
//启动线程
TestJoin myJion = new TestJoin();
Thread thread = new Thread(myJion);
thread.start();
//主线程
for (int i = 0; i < 100; i++) {
if(i==50){
thread.join();
}
System.out.println("主线程执行"+i);
}
}
}
线程优先级
- Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，线程调度器按照优先级决定调度哪个线程来执行
- 线程的优先级用数字表示，范围从1~10
- Thread. MIN_PRIORITY=1
- Thread. NORM_PRIORITY=5
- Thread.MAX_PRIORITY=10
- 使用以下方式改变获取优先级
- getPriority() setPriority()
例子：
package com.sun.test;
//测试线程优先级
public class TestPriority {
public static void main(String[] args) {
//主线程优先级（默认）
System.out.println(Thread.currentThread().getName()+"---"+Thread.currentThread().getPriority());
MyPriority myPriority = new MyPriority();
Thread t1 = new Thread(myPriority);
Thread t2 = new Thread(myPriority);
Thread t3 = new Thread(myPriority);
Thread t4 = new Thread(myPriority);
t1.start();
t2.setPriority(Thread.MAX_PRIORITY);
t2.start();
t3.setPriority(Thread.NORM_PRIORITY);
t3.start();
t4.setPriority(4);
t4.start();
}
}
class MyPriority implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"---"+Thread.currentThread().getPriority());
}
}
守护线程
- 线程分为用户线程和守护线程
- 虚拟机必须确保用户线程执行完毕
- 虚拟机不用等待守护线程执行完毕
- 如后台记录操作日志，监控内存，垃圾回收等待
例子：
package com.sun.test;
//测试守护线程
public class TestDaemon {
public static void main(String[] args) {
God god = new God();
Person person = new Person();
//启动守护线程
Thread thread = new Thread(god);
thread.setDaemon(true);//默认为false，用户线程
thread.start();
//启动用户线程
new Thread(person).start();
}
}
//上帝
class God implements Runnable{
@Override
public void run() {
while(true){
System.out.println("god daemon person");
}
}
}
//人
class Person implements Runnable{
@Override
public void run() {
for (int i = 0; i < 36500; i++) {
System.out.println("person live "+i+" day");
}
System.out.println("person dead");
}
}
线程同步
处理多线程问题时，多线程访问同一个对象，并且某些线程还想修改这个对象，这时候就需要线程同步。线程同步其实就是一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用
形成条件：队列+锁
由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带了访问问题，为了保证数据在方法中被访问的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可，存在一下问题：
1、一个线程持有锁导致其他所有需要此锁的线程挂起
2、在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
3、如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题
同步方法
由于我们可以通过private关键字来保证数据对象只能被方法访问，所以我们只需要只对方法提出一套机制，它包括两种用法：synchronized方法和synchronized块
同步方法：Public synchronized void method(int args){}
synchronized方法控制对象的访问，每一个对象对应一把锁，每一个synchronized方法都必须获得调用该方法的对象锁才能执行，否则线程会阻塞，方法一旦执行,就独占该锁，直到该方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行。
缺陷：若将一个大的方法申明为synchronized将会影响效率。
同步块
同步块：synchronized(Object){}
Object称为同步监视器
Object可以是任何对象，但是推荐使用共享资源作为同步监视器（增删改的对象）
同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身
同步监视器的执行过程
1、第一个线程访问，锁定同步监视器，执行其中的代码
2、第二个线程访问，发现同步监视器被锁定，无法访问
3、第一个线程访问完毕，解锁同步监视器
4、第二个线程访问，发现同步监视器没有锁，然后锁定并访问
死锁
多个线程各自占用一些共享资源，并且互相等待其他线程占有的资源才能运行，而导致两个或者多个线程都在等待对方释放资源，都停止执行的情景。某一个同步块同时拥有两个以上对象锁时，就可能发生死锁的问题。
产生死锁的四个必要条件：
1、互斥条件：一个资源每次只能被一个进程使用
2、请求与保持条件：一个进程因请求资源而阻塞时，对方获得的资源保持不放
3、不剥夺条件：进程以获得的资源，在未使用完之气，不能强行剥夺
4、循环等待条件：若干进程之前形成一种头尾相接的循环等待资源关系
避免死锁的方法：
破坏其中的任意一个或者多个条件就可以避免死锁的发生
例子：
package com.sun.test;
//测试死锁
public class TestLock {
public static void main(String[] args) {
Makeup g1 = new Makeup(0,"小红");
Makeup g2 = new Makeup(1,"小白");
g1.start();
g2.start();
}
}
//口红
class Lipstick{
}
//镜子
class Mirror{
}
class Makeup extends Thread{
static Lipstick lipstick = new Lipstick();
static Mirror mirror = new Mirror();
int choice;
String girlName;
Makeup(int choice,String girlName){
this.choice = choice;
this.girlName = girlName;
}
@Override
public void run(){
super.run();
try {
makeup();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void makeup() throws InterruptedException {
if(choice==0){
//这样会死锁
synchronized (lipstick){//获得口红
System.out.println(this.girlName+"获得口红的锁");
Thread.sleep(1000);
synchronized (mirror){//一秒后获得镜子
System.out.println(this.girlName+"获得镜子的锁");
}
}
/* //这样避免死锁
synchronized (lipstick){//获得口红
System.out.println(this.girlName+"获得口红的锁");
Thread.sleep(1000);
}
synchronized (mirror){//一秒后获得镜子
System.out.println(this.girlName+"获得镜子的锁");
}*/
}else{
//这样会死锁
synchronized (mirror){//获得口红
System.out.println(this.girlName+"获得镜子的锁");
Thread.sleep(1000);
synchronized (lipstick){//一秒钟后获得口红
System.out.println(this.girlName+"获得口红的锁");
}
}
/* //这样避免死锁
synchronized (mirror){//获得口红
System.out.println(this.girlName+"获得镜子的锁");
Thread.sleep(1000);
}
synchronized (lipstick){//一秒钟后获得口红
System.out.println(this.girlName+"获得口红的锁");
}*/
}
}
}
Lock（锁）
从JDK5.0开始，Java提供了更强大的线程同步机制，通过显示定义同步锁对想来实现同步。同步锁用Lock接口对象充当
java.util.concurrent.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独立访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前先获得Lock对象
ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentrantLock，可以显示加锁、释放锁
例子：
package com.sun.test;
import java.util.concurrent.locks.ReentrantLock;
public class TestLock {
public static void main(String[] args) {
TestLock2 testLock2 = new TestLock2();
new Thread(testLock2 ).start();
new Thread(testLock2 ).start();
new Thread(testLock2 ).start();
}
}
class TestLock2 implements Runnable{
int ticketNum = 10;
//定义锁
private final ReentrantLock reentrantLock = new ReentrantLock();
@Override
public void run() {
while(true){
try {
reentrantLock.lock();//加锁
if(ticketNum>0){
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(ticketNum--);
}else{
break;
}
}finally {
reentrantLock.unlock();//解锁
}
}
}
}
线程协作
Java提供了几个方法解决线程之前的通信问题
- wait()：表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
- wait(long timeout)：指定等待的毫秒数
- notify()：唤醒一个处于等待状态的线程
- notifyAll()：唤醒同一个对象上所有调用wait()方法的线程，优先级高的线程优先调度
注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常lllengalMonitorStateException
生产者/消费者模式
管程法：生产者将生产好的数据放入缓冲区，消费者从缓冲区中拿数据
信号灯法：通过设置一个标志位
线程池
背景：经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响比较大
思路：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，可以避免频繁创建销毁、实现重复利用
好处：
1、提高响应速度（减少了创建线程的时间）
2、降低资源消耗（重复利用线程池中线程，不要每次都创建）
3、便于线程管理
JDK5.0提供了线程池相关API： ExecutorService和Executors
ExecutorService：真正的线程池接口。常见子类ThreadPoolExecutor
- void execute(Runnable command)：执行任务，没有返回值，一般用来执行Runnable
-
Future submit(Callable task)：执行任务，有返回值，一般用来执行Callable - void shutDown()：关闭连接池
Executors：工具类、线程的工厂类，用于创建并返回不同类型的线程池
例子：
package com.sun.test;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
//测试线程池
public class TestPool {
public static void main(String[] args) {
//创建线程服务，创建线程池
//参数为线程池大小
ExecutorService service = Executors.newFixedThreadPool(10);
//执行
service.execute(new MyThread());
service.execute(new MyThread());
service.execute(new MyThread());
//关闭连接
service.shutdown();
}
}
class MyThread implements Runnable{
@Override
public void run() {
System.out.println(Thread.currentThread().getName());
}
}
欢迎大家在评论区提出宝贵意见！