大家好，本篇博文将会和大家分享关于“多线程”内容的基础部分。“多线程和高并发”作为java学习中一块非常难啃的骨头，本身难度很大，但是依然无法阻止我们向着“牛逼java人”迈进；up将来会在《java高级》专栏与大家分享“多线程和高并发”的相关内容。本篇博文主要面向基础阶段，但是，虽说是基础，该说的我们还是不会含糊。

注意：①代码中的注释也很重要；②不要眼高手低，行之明觉精察处即是知，自己动手跟着过一遍才算有收获；③点击文章前面的目录或者侧边栏目录可以进行跳转。良工不示人以朴，所有文章都会适时改进。感谢阅读！

二、定义

1.进程 :

进程是指程序的一次执行过程，或者说是正在运行的一个程序；当我们启动了某个应用程序时，就启动了一个进程，操作系统就会为该进程分配内存空间。进程是一个动态过程，自身有产生，存在和消亡的过程。

比方说，up现在打开了百度网盘，那么，当前百度网盘就是一个进程，我们可以在任务管理器的“进程”栏中看到它。如下图所示 :

2.线程 :

线程是由进程创建的，是进程的一个实体。一个进程可以拥有多个线程。

比方说，启动百度网盘后，就启动了一个进程，而在百度网盘中我们可以同时启动多个下载任务，这些下载任务就是百度网盘这个进程所创建的线程。如下图所示 :

3.单线程与多线程 :

单线程——同一时刻，只允许执行一个线程。

多线程——同一时刻，可以执行多个线程。eg : 百度网盘可以同时下载多个任务；谷歌浏览器可以同时打开多个页面；qq可以同时打开多个聊天窗口，等等。

4.并发与并行 :

并发——同一时间间隔内，多个任务在宏观上同时执行；单核CPU实现的多任务处理就是并发。实际上，单核CPU在同一时刻只能处理一道程序（一个任务），因此微观上单核CPU的多任务处理是通过“分时交替”来实现的；即，将某一时间间隔分成许多的时间片，然后在不同的时间片不停地切换正在处理的任务，宏观上给人的感觉就是“同时执行”了。

并行——同一时刻可以完成两种或两种以上的任务的处理；并行需要相关硬件的支持，多核CPU可以实现并行。（一般来说，多核CPU的处理是并发和并行同时存在的）。

三、线程的创建

1.创建线程的两种基本方式 :

1° 继承Thread类，并重写run方法

我们先来看一下Thread是什么意思，如下图所示 :

在java中，Thread表示线程，来看一下Thread类的类图，如下 :

可以看到，Thread类其实是实现了Runnable接口，所以才有了两种创建线程的方式。

对于第一种创建线程的方式，up以Thread_Demo1类为测试类，在源文件中定义Grape类去继承Thread类并重写run方法。代码如下 : （注意看注释）

packagecsdn.knowledge.thread;
/*** @author : Cyan_RA9* @version : 21.0*/publicclassThread_Demo1 {
publicstaticvoidmain(String[] args) {
//创建线程对象Grapegrape=newGrape();
//启动线程！grape.start();
/*通过start方法启动线程，默认会调用线程类中的run方法。*/    }
}
classGrapeextendsThread {    /**当某个类继承了Thread类后，就可以当作线程使用*/privateinttimes=0;      //定义times变量，用于统计run方法被执行的次数。/*一般要重写run方法（本质是实现了Runnable接口中的抽象方法），以实现自己的业务需求。*/@Overridepublicvoidrun() {
while (true) {
System.out.println("我被吃第"+++times+"次了😭！");
/*Thread类中的静态方法sleep可以让线程休眠指定时间，传入的实参以毫秒为单位。使用sleep方法时会出现编译期异常，可以使用Ctrl + Alt + t/T快捷键，然后选择使用try-catch包围。*/try {
Thread.sleep(500);      //让线程每执行一次run方法就休眠0.5秒            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
if (times>=11)            //执行11次后，跳出while循环break;
        }
    }
}

运行效果：（如下GIF图）

1.5° 多线程的执行机制(重要)

以上面代码为例, 当我们点击“Run 'Thread_Demo1.main()' "运行该程序时，就相当于启动了一个进程，而main函数作为程序的入口，它是当前进程所启动的第一个线程，作为主线程；当main函数执行到grape.start()方法时，主线程就会启动一个子线程，即第二个线程。

注意：当第二个线程启动时，主线程不会受到影响而阻塞。也就是说，假设main函数中的"grape.start(); "语句后面还有其他的语句，则在start方法执行后会继续执行下去，不会等着启动的第二个线程完毕后才接着执行。因此，假设我们在"grape.start();"语句后面增加一些输出语句，我们就可以在控制台看到两个线程交替执行的画面。

当然，进行代码演示前，先给大家来张流程图——如下 :

为了验证我们上面的说法，我们在上面Thread_Demo1类代码的基础上，添加一些新的东西——我们在main函数第一行语句打印出当前线程的名字（具体打印步骤在代码注释中），并在线程类run方法的第一行打印出第二个线程的名字；
然后在main函数的"grape.start();" 语句后面再加上一个for循环语句，并且，为了模拟线程交替执行的效果，我们在for循环中也使用Thread.sleep()方法，令main线程也每0.5秒休眠一次。

代码如下 :

packagecsdn.knowledge.thread;
publicclassThread_Demo1 {
publicstaticvoidmain(String[] args) throwsInterruptedException {    //使用sleep方法会产生编译期异常//先来看看主线程叫啥名字吧，不会就叫main吧？/*通过Thread类的静态方法currentThread可以获取到当前线程对象，而通过getName方法，可以获得当前线程对象的名字。*/System.out.println("第一个线程是："+Thread.currentThread().getName());
//创建线程对象Grapegrape=newGrape();
//启动线程！grape.start();
/*通过start方法启动线程，默认会调用线程类中的run方法。*/for (inti=0; i<5; ++i) {
System.out.println("主线程正在执行中，这是👴第 "+ (i+1) +" 次出现。");
Thread.sleep(500);
        }
    }
}
classGrapeextendsThread {    /**当某个类继承了Thread类后，就可以当作线程使用*/privateinttimes=0;      //定义times变量，用于统计run方法被执行的次数。/*一般要重写run方法（本质是实现了Runnable接口中的抽象方法），以实现自己的业务需求。*/@Overridepublicvoidrun() {
//那第二个线程默认名字是啥呢？System.out.println("第二个线程是："+Thread.currentThread().getName());
while (true) {
System.out.println("我被吃第"+++times+"次了😭！");
/*Thread类中的静态方法sleep可以让线程休眠指定时间，传入的实参以毫秒为单位。使用sleep方法时会出现编译期异常，可以使用Ctrl + Alt + t/T快捷键，然后选择使用try-catch包围。*/try {
Thread.sleep(500);      //每执行一次while循环，就让线程休眠0.5秒            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
if (times>=11)
break;
        }
    }
}

运行效果：（如下GIF图）

我们不但可以清楚地看到主线程和Thread-0线程交替执行的情况，而且也可以看到主线程的确就叫“main”，start启动的第二个线程确实就叫“Thread-0”。更重要的是，当主线程挂掉后，Thread-0线程还行继续运行，并在控制台上不停地打印信息。

注意：当主线程（main线程）挂掉后（执行完毕），由于Thread-0线程还在运行，所以当前进程并没有结束，而是直到所有线程都挂掉了，进程才退出的。

因此，我们可以得出结论——多线程中，不会因为main线程的退出就退出整个进程；而是当当前进程的所有线程都退出后，才退出当前进程。

PS :

这时候，可能就要有p小将（Personable小将，指风度翩翩的人）出来~~挑事儿~~问问题了——看你写得代码注释，既然start方法默认会调用run方法，那我直接调用run方法不就得嘞，为啥还要调用一下start方法捏，这不是脱裤子放屁😅？

(ಥ _ ಥ)（/感动），p小将总算问出个正经问题了。

好的，我们先来看看——如果将start方法替换为run方法，会是怎样的输出效果？如下GIF图演示 :

可以看到，最明显的改变就是run方法中的内容与main方法中的内容不再是挨个轮流的输出了，即不再有线程交替执行的现象了。而是先执行完了run方法中的内容，才接着执行main函数中剩余的其他内容，即主线程出现了阻塞。

其实，打印出的线程名已经告诉了我们答案——第二个线程是：main。说明整个程序（进程）的执行过程中就只有main线程一个线程，压根没启动新的线程。这与start方法的特点有关。在start方法的源码中，我们可以找到一个start0方法，如下图所示 :

我们可以根据 Ctrl + b/B 快捷键来继续查看start0方法的源码，如下 :

可以看到，start0方法其实是Thread类中的一个native方法，native方法表示该方法是由C和C++实现的，由jvm来底层调用，程序员无法手动调用。而start0方法关系到了新线程的启动。

注意 : start()方法调用了start0()方法后，该线程并不一定会马上执行，只是将线程变成了可运行状态。具体什么时候执行取决于CPU，由CPU来统一调度。如下图所示 :

2° 实现Runnable接口，并重写run方法

在面向对象专题我们说过，java是单继承机制，不允许同一类去继承多个类；在某些情况下，一个类已经继承了另一个类，这时如果我们想把这个类当作线程类来使用，显然无法使用第一种方法。

java的设计者们提供了第二种方式来创建线程——直接实现Runnable接口，并重写run方法。我们前面说过，第一种创建线程的方式（继承Thread类并重写run方法）根本上靠的是Runnable接口中的run方法，因为Thread类中的run方法其实就是实现了Runnable接口中的run方法。如下图所示 :

所以，我们跳过Thread类，直接实现Runnable接口并重写run方法，理论上是完全可行的，start方法最终不就是要调用run方法么。

好的，up就以Thread_Demo2类为测试类，在源文件中另定义Apple类和Fruit类，并让Apple类先继承Fruit类，再实现Runnable接口并重写run方法，如下图所示 :

接着，我们还是按部就班地在测试类main方法中创建线程类对象，并调用start方法；然而，你会发现你想骂娘了，如下图所示 :

我**（咋回事儿啊？），没错，不懂人情世故的IDEA居然说没有找到start方法！Crazy！

当然，其实原因很简单😂。我们来看一下Runnable接口的方法类图，如下 :

噢，原来Runnable接口是个光棍儿啊（bushi）。 Runnable接口中不存在start方法，你仅仅是实现了Runnable接口，通过Apple类对象来调用start方法当然找不到。那就没有解决方案吗？

当然有😎，这里我们要用到“代理模式”，什么意思呢？说得通俗点，就是说——start方法不是在Thread类中吗，那我们请Thread类出山，帮咱个忙不就行了。

代码如下 :

packagecsdn.knowledge.thread;
/*** @author : Cyan_RA9* @version : 21.0*/publicclassThread_Demo2 {
publicstaticvoidmain(String[] args) throwsInterruptedException {
System.out.println("第一个线程是："+Thread.currentThread().getName());
Appleapple=newApple();
//请Thread大仙出山帮个忙Threadthread=newThread(apple);
thread.start();
for (inti=0; i<5; ++i) {
System.out.println("主线程正在运行 "+ (i+1));
Thread.sleep(500);
        }
    }
}
classFruit {}
classAppleextendsFruitimplementsRunnable {
inttimes=0;
@Overridepublicvoidrun() {
System.out.println("第二个线程是："+Thread.currentThread().getName());
while (true) {
System.out.println("Apple NB! "+ (++times));
try {
Thread.sleep(500);
            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
if (times>=11)
break;
        }
    }
}

运行效果：

这里我们用到了一个Thread类的带参构造，如下 :

它可以接收一个Runnable接口类型的引用变量，那显然我们可以把Apple类对象丢给它，接口的多态么。用Thread类的带参构造把Apple类对象封装起来后，就可以使用thread引用来调用start方法了。Thread类在这里就相当于是一个代理类，帮助我们使用真正的线程类Apple。

2. 两种创建线程方式的比较 :

1°从java的设计来看，通过继承Thread类并重写run方法（第一种方式）或者通过实现Runnable接口并重写run方法（第二种方式），这两种创建线程的方式在本质上没有区别。最终都是要通过Thread类中的start方法来调用底层的start0方法，从而启动一个新的子线程，并执行子线程类中的run方法。

2° 但是，通过实现Runnable接口并重写run方法（第二种方式）来创建线程，更加适合多个子线程共享一个资源的情况。比如说，我们可以将同一个线程类对象传递给多个代理，以使得多个线程处理同一个对象，如下所示 :

//以下代码仅作为演示，无实际意义publicstaticvoidmain(String[] args) {
Testtest=newTest();
Threadthread_1=newThread(test);
Threadthread_2=newThread(test);
thread_1.start();
thread_2.start();
}
classTestimplementsRunnable {
@Overridepublicvoidrun() {
//body    }
}

那么，只要我们在线程类的run方法中写上相应的业务代码，就可以实现“启动的多个子线程”共享一个资源的情景。

除此之外，使用第二种方式还可以规避单继承机制的约束。因此，平时的实际开发中，建议大家用第二种方式——实现Runnable接口并重写run方法——来创建子线程。

四、线程的方法

1. setName(String name) 和 getName() :

setName方法可以设置当前线程的名称；

而getName方法可以返回当前线程的名称。若没有为当前线程设置名称，则返回默认名称。

2.start() 和 run() :

start方法会启动新的线程，因为jvm会调用其底层的start0方法；

而线程对象的run方法仅仅是一个简单的方法调用，并不会启动新的线程。

3.setPriority(int newPriority) 和 getPriority() :

先来看一下Priority是什么意思，如下 :

setPriority方法可以更改当前线程的优先级；

而getPriority方法可以获取当前线程的优先级。

Thread类中提供了三种优先级别，我们可以查看源码，如下 :

1°MIN_PRIORITY——线程可以设置的最低优先级别，用int类型1表示；

2°NORM_PRIORITY——线程默认的优先级别，用int类型5表示；

3°MAX_PRIORITY——线程可以设置的最高优先级别，用int类型10表示。

4.sleep(long millis) 和 interrupt() :

sleep方法可以让当前线程休眠指定的毫秒数（暂停执行）；

而interrupt方法可以中断当前线程。由于interrupt方法并没有真正的结束当前线程，所以一般用来中断正在休眠的线程——即，对正在休眠的线程使用interrupt方法可以使其结束休眠，相当于“唤醒”正在休眠的线程。

5.Δ代码演示 :

up以Thread_Demo4类为演示类，代码如下 : （先看Cat类中的代码注释）

packagecsdn.knowledge.thread;
publicclassThread_Demo4 {
publicstaticvoidmain(String[] args) throwsInterruptedException {
Catcat=newCat();
Threadthread=newThread(cat);
//启动线程！thread.start();
//setName 和 getNameSystem.out.println("old name = "+thread.getName());
thread.setName("线程1号");
System.out.println("new name = "+thread.getName());
//setPriority 和 getPrioritySystem.out.println("\nold priority = "+thread.getPriority());
thread.setPriority(Thread.MIN_PRIORITY);
System.out.println("new priority = "+thread.getPriority());
//先让主线程 main休眠 5s，等待run方法第一个for循环执行完成。Thread.sleep(5*1000);
/*子线程休眠20s太长了，不想等了，倒计时3秒直接唤醒正在休眠的子线程*/for (inti=3; i>0; --i) {
System.out.println("唤醒子线程倒计时："+i+"~");
Thread.sleep(1*1000);
        }
//唤醒正在休眠的子线程！thread.interrupt();
    }
}
classCatimplementsRunnable {
@Overridepublicvoidrun() {
//run方法中第一个for循环for (inti=0; i<5; i++) {
System.out.println("我是一只猫~ (number."+ (i+1) +")");
//每执行一次for循环，令子线程休眠1秒（以展示出效果）try {
Thread.sleep(1*1000);
            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
        }
try {
//正常情况下，执行完run方法中第一个for循环后，令子线程休眠20秒。Thread.sleep(20*1000);
        } catch (InterruptedExceptione) {
/*当执行interrupt方法中断子线程的休眠时，就会catch到一个InterruptedException类型的异常对象；我们可以在catch语句中写上自己的业务代码。*/System.out.println("\n捕获到异常——"+e.getMessage());
System.out.println(Thread.currentThread().getName() +"被唤醒！（被interrupt了）\n");
        }
//run方法中第二个for循环for (inti=0; i<5; i++) {
System.out.println("快乐的星猫~ (no."+ (i+1) +")");
try {
Thread.sleep(500);
            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
        }
    }
}

运行效果：（如下GIF图）

五、线程的操作

1.线程退出：

线程的退出主要分为两种情况——

1° 当线程对应的任务执行完毕后，线程会自动退出。

2°可以使用“通知”的方式来退出线程，即通过使用变量来控制run方法退出来停止线程。

up以Thread_Demo3类为测试类，在源文件下定义Car类，并使用实现Runnable接口重写run方法的方式来创建Car类的线程。在Car类中定义控制变量，使主线程可以根据该控制变量来控制run方法的退出，从而退出子线程。

代码如下 :

packagecsdn.knowledge.thread;
publicclassThread_Demo3 {
publicstaticvoidmain(String[] args) throwsInterruptedException {
System.out.println("主线程启动——"+Thread.currentThread().getName());
//创建线程类对象Carcar=newCar();
//请Thread大仙出山Threadthread=newThread(car);
//启动子线程!thread.start();
//令主线程休眠11秒，当主线程休眠结束后，终止run方法，子线程退出。Thread.sleep(11*1000);
System.out.println("主线程已休眠11s，令子线程退出！");
car.setLoop(false);
    }
}
classCarimplementsRunnable{
//添加控制变量privatebooleanloop=true;
privateinttimes;
@Overridepublicvoidrun() {
System.out.println("子线程启动——"+Thread.currentThread().getName());
//控制变量可以控制while循环何时结束while (loop) {
System.out.println("道路千万条，安全第一条；行车不规范，亲人两行泪。* "+ (++times));
//每执行一次while循环，令子线程休眠0.5秒try {
Thread.sleep(500);
            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
        }
System.out.println("子线程已退出！");
    }
//提供控制变量loop的setter方法，使主线程可以随时通知子线程退出.publicvoidsetLoop(booleanloop) {
this.loop=loop;
    }
}

运行效果：（如下GIF图）

2. 线程插队 :

1°yield() : 静态方法，可以实现线程的礼让。该方法可以让出CPU对当前线程的服务，使得CPU可以专注于执行其他的线程，但是礼让的具体效果取决于CPU的底层调度，一般在资源紧张的情况下更容易礼让成功，其中涉及到了操作系统的底层。所以，使用yield方法不一定礼让成功。

2° join() : 该方法可以实现线程的插队。并且，一旦插队成功，就一定会优先将插队的线程的所有任务都执行完毕。PS : 想让谁插队，就调用谁的join方法。

up以Thread_Demo5类为测试类，要达到如下效果——主线程输出滕王阁序的第一段和最后两段，中间部分全部由子线程输出；代码如下 :

packagecsdn.knowledge.thread;
publicclassThread_Demo5 {
publicstaticvoidmain(String[] args) {
Poempoem=newPoem();
Threadthread=newThread(poem);
//启动子线程！thread.start();
System.out.println("        豫章故郡，洪都新府。星分翼轸，地接衡庐。襟三江而带五湖，控蛮荆而引瓯越。\n"+"    物华天宝，龙光射牛斗之墟；人杰地灵，徐孺下陈蕃之榻。雄州雾列，俊采星驰。\n"+"    台隍枕夷夏之交，宾主尽东南之美。都督阎公之雅望，棨戟遥临；宇文新州之懿范，襜帷暂驻。\n"+"    十旬休假，胜友如云；千里逢迎，高朋满座。腾蛟起凤，孟学士之词宗；紫电青霜，王将军之武库。\n"+"    家君作宰，路出名区；童子何知，躬逢胜饯。\n");
//让子线程插队，优先执行子线程的全部任务。try {
thread.join();
        } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
        }
System.out.println("        勃，三尺微命，一介书生。无路请缨，等终军之弱冠；有怀投笔，慕宗悫之长风。\n"+"    舍簪笏于百龄，奉晨昏于万里。非谢家之宝树，接孟氏之芳邻。他日趋庭，叨陪鲤对；\n"+"    今兹捧袂，喜托龙门。杨意不逢，抚凌云而自惜；钟期既遇，奏流水以何惭？\n"+"\n"+"        呜呼！胜地不常，盛筵难再；兰亭已矣，梓泽丘墟。临别赠言，幸承恩于伟饯；\n"+"    登高作赋，是所望于群公。敢竭鄙怀，恭疏短引；一言均赋，四韵俱成。请洒潘江，各倾陆海云尔。\n");
    }
}
classPoemimplementsRunnable {
@Overridepublicvoidrun() {
System.out.println("        时维九月，序属三秋。潦水尽而寒潭清，烟光凝而暮山紫。俨骖騑于上路，访风景于崇阿。\n"+"    临帝子之长洲，得天人之旧馆。层峦耸翠，上出重霄；飞阁流丹，下临无地。\n"+"    鹤汀凫渚，穷岛屿之萦回；桂殿兰宫，即冈峦之体势。\n"+"　　\n"+"        披绣闼，俯雕甍，山原旷其盈视，川泽纡其骇瞩。闾阎扑地，钟鸣鼎食之家；\n"+"    舸舰弥津，青雀黄龙之舳。云销雨霁，彩彻区明。落霞与孤鹜齐飞，秋水共长天一色。\n"+"    渔舟唱晚，响穷彭蠡之滨，雁阵惊寒，声断衡阳之浦。\n");
//让子线程每执行完一条语句就休眠1s，以展示出效果。try {
Thread.sleep(1*1000);
        } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
        }
System.out.println("        遥襟甫畅，逸兴遄飞。爽籁发而清风生，纤歌凝而白云遏。睢园绿竹，气凌彭泽之樽；\n"+"    邺水朱华，光照临川之笔。四美具，二难并。穷睇眄于中天，极娱游于暇日。\n"+"    天高地迥，觉宇宙之无穷；兴尽悲来，识盈虚之有数。望长安于日下，目吴会于云间。\n"+"    地势极而南溟深，天柱高而北辰远。关山难越，谁悲失路之人；萍水相逢，尽是他乡之客。\n"+"    怀帝阍而不见，奉宣室以何年？\n");
try {
Thread.sleep(1*1000);
        } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
        }
System.out.println("        嗟乎！时运不齐，命途多舛。冯唐易老，李广难封。屈贾谊于长沙，非无圣主；\n"+"    窜梁鸿于海曲，岂乏明时？所赖君子见机，达人知命。老当益壮，宁移白首之心？\n"+"    穷且益坚，不坠青云之志。酌贪泉而觉爽，处涸辙以犹欢。北海虽赊，扶摇可接；\n"+"    东隅已逝，桑榆非晚。孟尝高洁，空余报国之情；阮籍猖狂，岂效穷途之哭！\n");
    }
}

运行效果：（如下GIF图）

可以看到，子线程执行的run方法中，每输出一句都要休眠1秒钟。但是由于子线程插队，cpu必须将子线程的run方法执行完毕后才能继续回到主线程执行剩余部分。

3.线程守护 :

用户线程：也叫工作线程；退出方式有两种——①任务执行完毕后自动退出；②通过通知的方式退出。

守护线程：守护线程一般是为工作线程来服务的。守护线程存在的目的是——当其他所有的线程都退出后，守护线程才自动退出。常见的守护线程就是——java中的垃圾回收机制。

对于守护线程，你可以理解为——就是一个“兜底的”，比方说，一个宿舍六个人，规定谁最晚上床谁关灯，那最后留下的那个哥们，一定是在其他五个人均已上床后，它才去关灯，然后上床。此时，最后关灯的哥们就相当于是一个“守护者”😎。

守护线程的英文是Demon，如下：

up以Thread_Demo6类为测试类，代码如下 :

packagecsdn.knowledge.thread;
publicclassThread_Demo6 {
publicstaticvoidmain(String[] args) throwsInterruptedException {
Yeye=newYe();
Threadthread=newThread(ye);
//设置ye为守护线程thread.setDaemon(true);
//启动👴线程thread.start();
//当for循环执行完毕后，主线程就会退出，此时没有其他线程运行了，因此守护线程👴也会退出。for (inti=0; i<11; ++i) {
System.out.println("此处不留👴，自有👴光处!"+ (i+1));
//每执行一次for循环，让主线程休眠1s，以展示出效果Thread.sleep(1000);
        }
    }
}
classYeimplementsRunnable {
@Overridepublicvoidrun() {
inttimes=0;
/*一个死循环，如果不是守护线程的话，永远不会退出。*/while (true) {
System.out.println("卷死👴了! "+ (++times));
//每执行一次while循环，令子线程休眠0.5秒，不然太快了try {
Thread.sleep(500);
            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
        }
    }
}

运行效果：（如下GIF图）

六、线程的状态

1.线程的7种状态：

首先我们得明白，java语言的设计者——即java官方的标准到底定义了几种线程的状态。通过查看Thread类的源代码，我们可以在其中找到一个内部类State，如下图所示 :

显然State类是一个枚举类，java的设计者在该枚举类中给出了线程的状态，共6种。我们也可以在API文档中直接查看，如下图所示 :

官方定义的线程的6种状态分别为——

①NEW（尚未启动）；
②RUNNABLE（正在JVM中执行）；
③BLOCKED（被阻塞）；
④WAITING（等待其他线程执行特定任务）；
⑤TIMED_WAITING（等待指定时间）；
⑥TERMINATED（业已退出）。

这时候可能就要有p小将（Personable小将，指风度翩翩的人）出来bb问了：丫的牛头不对马嘴！标题还写着7种状态，写着写着变成6种了，搁这儿阉割呢？

诶，p佬先别急，这不，下面一张线程生命周期图就给大伙儿说明白了。

2.线程的生命周期图：（重要)

如下图所示 :

老规矩，我们一步一步来看——

1° 当我们通过new关键字创建一个新的线程对象后，线程就处于“NEW”的状态（新建状态）；

2° 当start() 方法中的start0() 方法正式启动新的线程后，线程就进入了“RUNNABLE”的状态（可运行状态）。"RUNNABLE"对应上图中间的粉色大矩形框.

因此, 如果我们细分的话, “RUNNABLE”状态又可分为两种具体的状态——Ready（就绪状态）和Running（运行状态）；其中，就绪状态Ready表示当前线程可以运行，但最终会不会被执行要取决于该线程会不会被调度器选中; 如果线程被选中执行，那线程就进入了运行状态Running。

也就是说，如果我们把Ready和Running合并看作一个状态，也就是RUNNABLE（可运行状态），那线程就可以处于６种状态的一种，与java的官网文档相匹配；但如果我们细化，那就是我们上面标题说的“7种状态”。

3° 当线程的任务执行完毕后，线程就会进入“TERMINATED”状态（终止状态），可称为线程“死掉了”或者“挂掉了”。

4°如果一个正处于RUNNABLE状态的线程，调用了一个锁，线程就可能进入“BLOCKED”状态（阻塞状态），直到获得锁后重新进入RUNNABLE状态。

5° 如果一个处于RUNNABLE状态的线程遇到了wait, join, park这些方法，就可能进入“WAITING”状态（等待执行状态）。比方说，我们上文中提到的join方法，当第二个线程通过join方法插队成功后，cpu就会优先去执行插队的线程，那么原先的第一个线程此时就处于WAITING状态，必须等待第二个线程执行完毕后，才能返回到第一个线程中继续执行。第一个线程也可以通过notify等方法重新回到RUNNABLE状态。

6° 对于“TIMED_WAITING”状态（超时等待状态），最经典的就是我们上面一直在用的sleep方法，令指定线程休眠指定时间，时间结束后重新回到RUNNABLE状态。

7° 对于RUNNABLE细分的两个状态Ready 和 Running，它们之间可以进行相互转化。比方说，可以将一个正在运行的线程挂起，使其进入就绪状态；或者对一个正在运行的线程使用yield方法进行礼让，使其进入就绪状态。其实，这张线程生命周期图也间接验证了我们之前提到的观点——使用yield方法不一定会礼让成功；因为yield之后只是进入就绪状态了，如果在资源充足的情况下，它可能重新被调度器选中并执行；而join方法则是直接将该线程置为了WAITING状态。

up以Thread_Demo7类为测试类，代码如下 :

packagecsdn.knowledge.thread;
publicclassThread_Demo7 {
publicstaticvoidmain(String[] args) throwsInterruptedException {
Statestate=newState();
Threadthread=newThread(state);
/*getState方法可以获取指定线程当前的状态。*/System.out.println("当前线程的状态——"+thread.getState());
thread.start();
/*只要线程当前的状态不为TERMINATED（终止状态），就不停输出它当前的状态。*/while (thread.getState() !=Thread.State.TERMINATED) {
System.out.println("当前线程的状态——"+thread.getState());
Thread.sleep(500);
        }
System.out.println("当前线程的状态——"+thread.getState());
    }
}
classStateimplementsRunnable {
@Overridepublicvoidrun() {
inttimes=0;
while (true) {
System.out.println("现在是啥子状态噢——"+ (++times));
try {
Thread.sleep(500);
            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
if (times>=5)
break;
        }
    }
}

运行效果：（如下GIF图）

七、线程同步机制

1.概述 :

在多线程编程中，一些敏感数据或者重要数据往往不允许被多个线程同时访问，因此会用到线程访问技术。通过线程同步机制，使得重要数据在同一时刻最多只能被一个线程访问，以保证数据的完整性。

所谓“线程同步”，即——当已经有一个线程对内存中的某些数据进行操作时，其他线程都不能访问这个内存地址。直到该线程执行完毕任务，其他线程才能对该内存地址进行操作。

2.使用 :

1° 同步代码块

synchronized (对象）{

//body（需要被同步的代码写在这儿）

}

Δ说明 :

使用“synchronized(对象)”的格式修饰代码块，称为“对象锁”，只有拿到了对象锁的线程才可以访问该同步代码块，访问完毕后，再将对象锁放回去。下一次线程如果想访问该同步代码块，需重复上述操作。

2° 同步方法

public synchronized void f(parameter list) {

//body（需要被同步的代码写到这儿）

}

Δ说明 :

synchronized关键字修饰方法，表示整个方法是一个同步方法。在同一时刻，同步方法只能被最多一个线程访问。

3.案例 :

利用线程同步机制解决经典的“超卖”问题。

up以Thread_Demo8类为测试类，代码如下 :

packagecsdn.knowledge.thread;
/*** 线程同步机制——* 解决经典“ 超卖 ”问题。*/publicclassThread_Demo8 {
publicstaticvoidmain(String[] args) {
//采用实现Runnable接口的方式创建线程类对象Conductorconductor=newConductor();
//给出三个代理，相当于售票员共有三位，三个线程共享一个资源。Threadthread1=newThread(conductor);
thread1.setName("售票员1号");
Threadthread2=newThread(conductor);
thread2.setName("售票员2号");
Threadthread3=newThread(conductor);
thread3.setName("售票员3号");
//启动线程thread1.start();
thread2.start();
thread3.start();
    }
}
classConductorimplementsRunnable {
//所有售票员共售卖600张票privateintsum=600;
//控制变量privatebooleanloop=true;
/*1.因为所有线程默认都会调用run方法，所以，利用封装的思想相关业务代码封装到sell方法中。2.通过添加synchronized关键字，将sell方法设置为同步方法。同一时刻，仅允许有一个线程访问sell方法。*/publicsynchronizedvoidsell() {
//如果sum == 0，说明票买完了，直接走人儿！if (sum<=0) {
loop=false;
System.out.println("卖完了敖~");
return;
        }
//售票员使用机器卖票，每卖出一张就休眠0.01秒。try {
Thread.sleep(10);
        } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
        }
//实现显示当前还剩多少张票没有卖出。System.out.println(Thread.currentThread().getName() +"卖出一张票，"+"还剩 "+ (--sum) +" 张票。");
    }
@Overridepublicvoidrun() {
while (loop) {
sell();
        }
    }
}

运行效果 : (如下GIF图）

GIF图演示中，最后打印出了三句“卖完了敖~”，说明三个线程是真正存在的，但是为什么实际卖票的就一个线程呢？说来惭愧😂，因为up设置的票数少了，CPU不屑于调用售票员2号和售票员3号；经过实测，在up电脑上，如果设置500张以上，就可以看到他们了，但是设置的票数太多的话，最后录出来的GIF图片太大了不能上传，也是没办法。

当然，大家可以在自己电脑上试试，一般情况下出现其他售票员所需的票数越高，说明你电脑性能越好😂。休眠时间尽量设置的短一些更容易调用到其他线程。

八、关于“锁”

1.互斥锁

1° java中引入了“对象互斥锁”的概念，以保证共享数据操作的完整性。每个对象都对应于一个可称为“互斥锁”的标记，该标记用来保证同一时刻仅允许一个线程访问该对象。

2° 当某个对象被synchronized关键字修饰时，表明该对象在任一时刻仅允许被一个线程访问。

3° 如果是非静态的同步方法，它的锁默认是this，也可以是其他对象（要求是同一个对象）；如果是静态的同步方法，它的锁为当前类本身。

对于非静态方法，比方说，对于上面卖票问题的sell方法，我们可以把同步方法转换为同步代码块，“(对象)”中放入this，如下所示 :

public/*synchronized*/voidsell() {
//synchronized关键字修饰的同步代码块synchronized (this) {
if (sum<=0) {
loop=false;
System.out.println("卖完了敖~");
return;
            }
try {
Thread.sleep(10);
            } catch (InterruptedExceptione) {
thrownewRuntimeException(e);
            }
System.out.println(Thread.currentThread().getName() +"卖出一张票，"+"还剩 "+ (--sum) +" 张票。");
        }
    }

我们也可以自己定义一个对象来使用，如下图所示：

这么做也是可以的不会发生超卖现象。重点就在于——保证多个线程争夺的是同一个锁对象。

对于静态方法，同步的静态方法在形式上不变化；但若想在一个静态方法中定义一个同步代码块，需要将括号中的对象改为“类名.class”。

4°线程同步机制的局限性——会降低程序的执行效率。为了尽可能减少这种效率的损耗，建议优先使用同步代码块而不是同步方法，因为同步代码块范围更小更精准，相对同步方法效率更高。

2.死锁 :

线程的死锁是指——当多个线程都占用了对方的资源，但不肯相让，既不能释放资源也无法获取资源，就会导致死锁。

比方说，有两个线程A和B，A线程想获取B的资源，而B线程想获取A的资源；但是A线程和B线程又分别占据了A对应的资源和B对应的资源，此时A线程和B线程既无法释放资源也无法进一步获取资源，始终处于“BOLCKED”状态，造成死锁。

因此，编程中，我们应该尽量避免“死锁”的发生。

up以Thread_Demo9类为测试类，代码如下 :

packagecsdn.knowledge.thread;
publicclassThread_Demo9 {
publicstaticvoidmain(String[] args) {
/*为两个线程分别赋予不同的key值。*/Locklock1=newLock(true);
Locklock2=newLock(false);
lock1.setName("A线程——大头姐姐");
lock2.setName("B线程——小头哥哥");
lock1.start();
lock2.start();
    }
}
classLockextendsThread {
/*使用static修饰Object类型的对象，以保证多个线程共享相同的对象。*/staticprivateObjecto1=newObject();
staticprivateObjecto2=newObject();
privatebooleankey;
publicLock(booleankey) {
this.key=key;
    }
/*if语句和else语句中分别设置两个嵌套同步代码块，两把对象锁分别是o1和o2；只不过，if语句中是先抢o1对象，而else语句中是先抢o2对象。那么只要A,B两个线程的初始key值不同，就极容易发生死锁——A线程和B线程都卡在第一层同步代码块里出不来了！*/@Overridepublicvoidrun() {
if (key) {
synchronized (o1) {
System.out.println(Thread.currentThread().getName() +"拿到了o1对象锁！");
synchronized (o2) {
System.out.println("先拿到了o1，现在拿到了o2");
                }
            }
        } else {
synchronized (o2) {
System.out.println(Thread.currentThread().getName() +"拿到了o2对象锁！");
synchronized (o1) {
System.out.println("先拿到o2，现在拿到了o1");
                }
            }
        }
    }
}

运行结果：（卡着就不动了，程序永远不会自动停止）

3.释放锁 :

1° 常见释放锁的四种情况——

①当前线程对应的同步方法或者同步代码块执行完毕，线程自动退出。

人话 : 拉完了，完事儿就出来了😋。

②当前线程对应的同步方法或者同步代码块，在执行过程中遇到了break或者return。

人话 : 拉一半儿呢，老师👩‍💼点名了，夹断，出来。

③当前线程对应的同步方法或者同步代码块，在执行过程中遇到了未处理的Error或者Exception。

人话 : 拉着正酣😙呢，突然发现“彻硕儿”是坏的，拉出去的全掉楼下了，吓得赶紧出来😱。

④当前线程对应的同步方法或者同步代码块，在执行过程中遇到了线程对象的wait方法，线程暂停执行，并释放锁。

人话 : 蹲的腿都麻了还挤不出二两💩来，先出去补两斤地瓜，含章可贞，以时发也。

2° 常见不释放锁的两种情况——

①线程执行同步代码块或者同步方法时，程序调用了Thread.sleep(...)方法或者Thread.yield()方法，只是暂停当前线程的执行，并不会释放锁。对于前者，会使当前线程进入TIMED_WAITING状态，对于后者，会使当前线程进入Ready状态。

人话 : 前者——刚拉出一块儿大的，实在累的不彳亍了，先一屁股坐下去睡会儿😴，管他是什么触觉；后者——边拉边背诵“孔融让梨”的故事，幡然醒悟，不管是拉了多少还是正在往下坠，直接起身👍。

②线程执行同步代码块或者同步方法时，其他线程调用了该线程的suspend方法，将该线程挂起，但挂起后依然不会释放锁。PS : 不推荐使用suspend方法和resume方法，因为已经过时。

人话 : 你被打上了思想🧠钢印，始终认为自己想去拉，于是便占着茅坑不拉💩。

九、完结撒❀

🆗，以上就是我们“多线程”基础部分的全部内容。不出意外，多线程专题将是我们javaSE基础的最后一个专题了。之后up会将java基础，java进阶，java高级等内容总结到一块儿，进行一个汇总。感谢阅读！

System.out.println("END-----------------------------------------------------------------------------");

java 多线程基础 万字详解（通俗易懂）

一、前言

二、定义

1.进程 :

2.线程 :

3.单线程与多线程 :

4.并发与并行 :

三、线程的创建

1.创建线程的两种基本方式 :

1° 继承Thread类，并重写run方法

1.5° 多线程的执行机制(重要)

2° 实现Runnable接口，并重写run方法

2. 两种创建线程方式的比较 :

四、线程的方法

1. setName(String name) 和 getName() :

2.start() 和 run() :

3.setPriority(int newPriority) 和 getPriority() :

4.sleep(long millis) 和 interrupt() :

5.Δ代码演示 :

五、线程的操作

1.线程退出 ：

2. 线程插队 :

3.线程守护 :

六、 线程的状态

1.线程的7种状态：

2.线程的生命周期图：（重要)

七、线程同步机制

1.概述 :

2.使用 :

1° 同步代码块

2° 同步方法

3.案例 :

八、关于“锁”

1.互斥锁

2.死锁 :

3.释放锁 :

九、完结撒❀

热门文章

最新文章

相关课程

相关电子书

相关实验场景

java 多线程基础万字详解（通俗易懂）

1.线程退出：

六、线程的状态