目录
一、概念
1、进程
2、线程
（1）单线程
（2）多线程
（3）并发
（4）并行
二、线程基本使用
1、创建线程的两种方式
（1）继承Thread类
（2）实现Runnable接口
（3）继承Thread和实现Runnable接口的区别
2、多线程执行
售票系统------>
3、线程常用方法
（1）第一组
（2）第二组
（3）用户线程和守护线程
三、线程终止
四、线程的生命周期
五、线程同步机制
1、同步概念
2、同步实现synchronized
（1）同步代码块
（2）方法声明
售票系统修正
3、互斥锁
4、线程死锁
5、释放锁
（1）以下操作会释放锁
（2）以下操作不会释放锁
一、概念
1、进程
进程是指运行中的程序，比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。
进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程：有它自身的产生、存在和消亡的过程。
2、线程
线程由进程创建的，是进程的一个实体
一个进程可以拥有多个线程
（1）单线程
同一个时刻，只允许执行一个线程
（2）多线程
同一个时刻，可以执行多个线程
（3）并发
同一个时刻，多个任务交替执行，造成一种“貌似同时”的错觉，简单的说，单核cpu实现的多任务就是并发。
（4）并行
同一个时刻，多个任务同时执行。多核cpu可以实现并行。
二、线程基本使用
1、创建线程的两种方式
- 继承Thread类，重写run方法
- 实现Runnable接口，重写run方法
（1）继承Thread类
案例1：请编写程序，开启一个线程，该线程每隔1秒。在控制台输出“瞄瞄,我是小猫咪"，
对上题改进：当输出80次瞄瞄，我是小猫咪，结束该线程。
想要看到线程，可以使用JConsole监控线程执行情况。
注意看注释哦！------>
关于其中用来开启线程的start方法：何不直接用run方法？
注意：run方法只是一个普通的方法，它不会启动一个新的线程，只是方法被调用而已，要把这个run方法执行完毕才能往下执行，并非多线程；需要start开启一个线程。
public class Thread01 {
public static void main(String[] args){
// 创建一个Cat对象，可以当做线程使用
Cat cat = new Cat();
cat.start(); // 启动线程
// 当main线程启动一个子线程后，主线程不会阻塞，会继续执行
// 这时主线程和子线程交替执行
System.out.print("主线程继续执行"+Thread.currentThread().getName()+"\n");
for(int i = 0; i < 10 ; i++){
System.out.print("主线程 i = "+i+"\n");
// 让主线程休眠
try{
Thread.sleep(1000);
}
catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
// 1、Thread类中的run方法是它实现了Runnable接口中的run
// 2、当一个类继承了Thread类，该类就可以当作线程使用
// 3、我们会重写run方法，写上自己的业务代码
class Cat extends Thread{
public void run(){
int count = 0;
while(count != 80){
count ++;
// 该线程每隔1秒。在控制台输出"瞄瞄,我是小猫咪"，
System.out.print("瞄瞄,我是小猫咪"+count+"\n");
// 让该线程休眠一秒
try{
sleep(1000); // 1000ms
}
catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
JConsole------>
先开始运行程序，然后在控制台中输入JConsole，连接当前进程，之后可在线程中查看相关情况。
（2）实现Runnable接口
案例2：请编写程序，该程序可以每隔1秒。在控制台输出“hi!”,当输出10次后，自动退出。请使用实现Runnable接口的方式实现。
public class Thread02 {
public static void main(String[] args){
Dog dog = new Dog();
Thread thread = new Thread(dog); // Dog类实现了Runnable接口
thread.start();
}
}
class Dog implements Runnable{
public void run(){
int count = 0;
while(count != 10){
count ++;
System.out.print("hi"+"\n");
try{
Thread.sleep(1000); // 1000ms
}
catch (InterruptedException e){
e.printStackTrace();
}
}
}
}
（3）继承Thread和实现Runnable接口的区别
- 从java的设计来看，通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk帮助文档我们可以看到Thread类本身就实现了Runnable接口 start()->start0()
- 实现Runnable接口方式更加适合多个线程共享一个资源的情况，并且避免了单继承的限制
2、多线程执行
案例3：请编写一个程序，创建两个线程，一个线程每隔1秒输出“hello,world!”，输出10次，退出，一个线程每隔1秒输出“hi!”，输出5次退出。
public class Thread03 {
public static void main(String[] args){
T1 t1 = new T1();
T2 t2 = new T2();
Thread thread1 = new Thread(t1);
Thread thread2 = new Thread(t2);
thread1.start();
thread2.start();
}
}
class T1 implements Runnable{
public void run(){
int count = 0;
while(count != 10){
count++;
System.out.println("Hello,world!"+count);
try{
Thread.sleep(1000);
}
catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
class T2 implements Runnable{
public void run(){
int count = 0;
while(count != 5){
count++;
System.out.println("hi!"+count);
try{
Thread.sleep(1000);
}
catch(InterruptedException e){
e.printStackTrace();
}
}
}
}
售票系统------>
模拟编程三个售票系统同时售票共100张
public class SellTicket {
public static void main(String[] args){
SellTicketUse use1 = new SellTicketUse();
SellTicketUse use2 = new SellTicketUse();
SellTicketUse use3 = new SellTicketUse();
use1.start();
use2.start();
use3.start();
}
}
class SellTicketUse extends Thread{
private static int num = 100;
public void run(){
while(true){
if(num <= 0) {
System.out.println("票已售完！");
break;
}
try{
sleep(50); // 模拟售票所需时间
}
catch (InterruptedException e){
e.printStackTrace();
}
num--;
System.out.println("窗口"+currentThread().getName()+"售出一张票，剩余票数"+num+"张");
}
}
}
出现负票数，以上代码得到的结果引出了多线程执行在实际事件中引发的问题：多个线程同时运行会致使共享的数据出现被穿插操作的现象，即上一个线程的买票操作还没有执行时，下一个线程就开始判断共享数据的大小。
此问题稍后会有解决办法。
3、线程常用方法
（1）第一组
注意事项------>
- start 底层会创建新的线程,调用run,run 就是一个简单的方法调用，不会启动新线程
- 线程优先级的范围
- interrupt，中断线程，但并没有真正的结束线程。所以一般用于中断正在休眠线程。
- sleep：线程的静态方法，使当前线程休眠
- 中断不是终止，InterruptedException是捕获到一个中断异常
（2）第二组
yield：线程的礼让。让出cpu，让其他线程执行，但礼让的时间不确定,所以也不一定礼让成功（根据资源是否紧张决定，资源紧张时更容易成功）
join：线程的插队。插队的线程一旦插队成功，则肯定先执行完插入的线程所有的任务
案例：创建一个子线程，每隔1s输出hello，输出20次，主线程每隔1秒，输出hi，输出20次。要求：两个线程同时执行，当主线程输出5次后，就让子线程运行完毕，主线程再继续。
public class ThreadMethod02 {
public static void main(String[] args){
TUse t2 = new TUse();
t2.start();
for(int i = 1; i <= 20; i++) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("主线程(小弟) 吃了 " + i + " 包子");
if(i == 5) {
System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
//join, 线程插队
//t2.join();// 这里相当于让t2 线程先执行完毕
Thread.yield();//礼让，不一定成功..
System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
}
}
}
}
class TUse extends Thread {
public void run() {
for (int i = 1; i <= 20; i++) {
try {
Thread.sleep(1000);//休眠1秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("子线程(老大) 吃了 " + i + " 包子");
}
}
}
（3）用户线程和守护线程
用户线程：也叫工作线程，当线程的任务执行完或通知方式结束
守护线程：一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束，常见的守护线程，垃圾回收机制
如何将一个线程设置成守护线程------>
public class ThreadMethod03 {
public static void main(String[] args){
MyDaemonThread myDaemonThread = new MyDaemonThread();
//如果我们希望当main线程结束后，子线程自动结束,
//只需将子线程设为守护线程即可
myDaemonThread.setDaemon(true); // 设置方法
myDaemonThread.start();
for( int i = 1; i <= 10; i++) {//main线程
System.out.println("嘿嘿嘿");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
class MyDaemonThread extends Thread {
public void run() {
while (true){//无限循环
try {
Thread.sleep(1000);//休眠1000毫秒
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("哈哈哈");
}
}
}
三、线程终止
- 当线程完成任务后，会自动退出。
- 还可以通过使用变量来控制run方法退出的方式停止线程，即通知方式。
需求：启动一个线程t，要求在main线程中去停止线程t，请编程实现。（通知方式）
public class ThreadExit {
public static void main(String[] args){
T t = new T();
t.start();
// 50s后终止该线程
try {
Thread.sleep(2000);
}
catch (InterruptedException e){
e.printStackTrace();
}
t.change(false);
}
}
class T extends Thread{
private boolean flag = true;
private int count = 0;
public void run(){
while(flag){
count ++;
System.out.print("hi"+count+"\n");
try{
Thread.sleep(1000); // 1000ms
}
catch (InterruptedException e){
e.printStackTrace();
}
if(count == 10){
break;
}
}
}
public void change(boolean flag){
this.flag = flag;
}
}
四、线程的生命周期
官方文档说法------>6个状态
关于一些教科书上7个状态的说法------>Runnable可运行状态分成了准备状态和正在运行的状态
可用代码观察到其中一些状态------>
public class ThreadMethodExercise {
public static void main(String[] args) throws InterruptedException {
Thread t3 = new Thread(new T3());//创建子线程
for (int i = 1; i <= 10; i++) {
System.out.println("hi " + i);
if(i == 5) {//说明主线程输出了5次 hi
t3.start();//启动子线程 输出 hello...
t3.join();//立即将t3子线程，插入到main线程，让t3先执行
}
Thread.sleep(1000);//输出一次 hi, 让main线程也休眠1s
}
}
}
class T3 implements Runnable {
private int count = 0;
public void run() {
while (true) {
System.out.println("hello " + (++count));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (count == 10) {
break;
}
}
}
}
五、线程同步机制
1、同步概念
在多线程编程，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术，保证数据在任何同一时刻，最多有一个线程访问，以保证数据的完整性。
也可以这样理解：线程同步，即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作，其他线程才能对该内存地址进行操作。
2、同步实现synchronized
（1）同步代码块
synchronized(对象){ // 得到对象的锁，才能操作同步代码
// 需要被同步的代码;
}
（2）方法声明
synchronized还可以放在方法声明中，表示整个方法为同步方法
public synchronized void m (String name){
//需要被同步的代码
}
售票系统修正
public class SellTicket {
public static void main(String[] args) {
SellTicket03 sellTicket03 = new SellTicket03();
new Thread(sellTicket03).start();//第1个线程-窗口
new Thread(sellTicket03).start();//第2个线程-窗口
new Thread(sellTicket03).start();//第3个线程-窗口
}
}
//实现接口方式, 使用synchronized实现线程同步
class SellTicket03 implements Runnable {
private int ticketNum = 100;//让多个线程共享 ticketNum
private boolean loop = true;//控制run方法变量
Object object = new Object();
//同步方法（静态的）的锁为当前类本身
//1. public synchronized static void m1() {} 锁是加在 SellTicket03.class
//2. 如果在静态方法中，实现一个同步代码块.
/*
synchronized (SellTicket03.class) {
System.out.println("m2");
}
*/
public synchronized static void m1() {
}
public static void m2() {
synchronized (SellTicket03.class) {
System.out.println("m2");
}
}
//1. public synchronized void sell() {} 就是一个同步方法
//2. 此时锁在this对象
//3. 也可以在代码块上写 synchronize ,同步代码块, 互斥锁还是在this对象
public /*synchronized*/ void sell() { //同步方法, 在同一时刻， 只能有一个线程来执行sell方法
synchronized (/*this*/ object) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
loop = false;
return;
}
//休眠50毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
}
}
@Override
public void run() {
while (loop) {
sell();//sell方法是一共同步方法
}
}
}
//使用Thread方式
// new SellTicket01().start()
// new SellTicket01().start();
class SellTicket01 extends Thread {
private static int ticketNum = 100;//让多个线程共享 ticketNum
// public void m1() {
// synchronized (this) {
// System.out.println("hello");
// }
// }
public void run() {
while (true) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
break;
}
//休眠50毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));
}
}
}
//实现接口方式
class SellTicket02 implements Runnable {
private int ticketNum = 100;//让多个线程共享 ticketNum
public void run() {
while (true) {
if (ticketNum <= 0) {
System.out.println("售票结束...");
break;
}
//休眠50毫秒, 模拟
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("窗口 " + Thread.currentThread().getName() + " 售出一张票"
+ " 剩余票数=" + (--ticketNum));//1 - 0 - -1 - -2
}
}
}
3、互斥锁
- Java语言中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。
- 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
- 关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时，表明该对象在任一时刻只能由一个线程访问。
- 同步的局限性：导致程序的执行效率要降低。
- 同步方法（非静态的）的锁可以是this（当前对象），也可以是其他对象（要求是同一个对象）
- 同步方法（静态的）的锁为当前类本身。（静态方法无对象）
实现步骤：
- 需要先分析上锁的代码
- 选择同步代码块或同步方法
- 要求多个线程的锁对象为同一个（好好理解一下），如果是不同的对象，那么意味着它们的锁也是不同的锁，那么它们根本没有争夺锁进入运行状态这一说法了（锁了个寂寞对吧）
4、线程死锁
多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生。
模拟线程死锁------>
public class DeadLock {
public static void main(String[] args) {
//模拟死锁现象
DeadLockDemo A = new DeadLockDemo(true);
A.setName("A线程");
DeadLockDemo B = new DeadLockDemo(false);
B.setName("B线程");
A.start();
B.start();
}
}
//线程
class DeadLockDemo extends Thread {
static Object o1 = new Object();// 保证多线程，共享一个对象,这里使用static
static Object o2 = new Object();
boolean flag;
public DeadLockDemo(boolean flag) {//构造器
this.flag = flag;
}
@Override
public void run() {
//下面业务逻辑的分析
//1. 如果flag 为 T, 线程A 就会先得到/持有 o1 对象锁, 然后尝试去获取 o2 对象锁
//2. 如果线程A 得不到 o2 对象锁（可能有另一个线程刚好拿了o2锁），就会Blocked
//3. 如果flag 为 F, 线程B 就会先得到/持有 o2 对象锁, 然后尝试去获取 o1 对象锁
//4. 如果线程B 得不到 o1 对象锁（可能有另一个线程刚好拿了o1锁），就会Blocked
if (flag) {
synchronized (o1) {//对象互斥锁, 下面就是同步代码
System.out.println(Thread.currentThread().getName() + " 进入1");
synchronized (o2) { // 这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入2");
}
}
} else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() + " 进入3");
synchronized (o1) { // 这里获得li对象的监视权
System.out.println(Thread.currentThread().getName() + " 进入4");
}
}
}
}
}
5、释放锁
（1）以下操作会释放锁
- 当前线程的同步方法、同步代码块执行结束。 案例：上厕所，完事出来
- 当前线程在同步代码块、同步方法中遇到break、return。 案例：没有正常的完事，经理叫他修改bug，不得已出来
- 当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，导致异常结束 案例：没有正常的完事，发现忘带纸,不得已出来
- 当前线程在同步代码块、同步方法中执行了线程对象的wait()方法，当前线程暂停，并释放锁。 案例：没有正常完事,觉得需要酝酿下，所以出来等会再进去
（2）以下操作不会释放锁
- 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行，不会释放锁。 案例：上厕所，太困了，在坑位上眯了一会
- 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁。
提示：应尽量避免使用suspend()和resume()来控制线程，方法不再推荐使用
--------------------------------------------------------线程结束-------------------------------------------------------------
![[附源码]计算机毕业设计springboot基于web的建设科技项目申报管理系统](https://img-blog.csdnimg.cn/ba5088ffeb8e4a89aee8264690550c43.png)
