java多线程核心api以及相关概念(一)
这篇博客总结了对线程核心api以及相关概念的学习，黑体字可以理解为重点，其他的都是我对它的理解
个人认为这些是学习java多线程的基础，不理解熟悉这些，后面的也不可能学好滴
目录
1.什么是线程以及优点
二，多线程如何使用
三，线程安全问题，
四，synchronized执行过程叙述
五，几个API：
六，停止线程，暂停线程
七，线程的优先级
八，守护线程
一，首先搞清楚什么是线程以及他的优点，我觉得一句话就就可以说清楚，线程就是一个进程的许多子任务。就比如你打开浏览器之后可能即浏览网页又在下载东西，你虽然你好像是同时做了两件事情，但其实是\cpu不停的在两个任务之间切换，只是切换的速度很快，感觉上是同时运行的，另外，线程是异步滴。
理解这个概念之后，来看线程的优点，都说多线程能够让任务的执行速度变快，我觉得这句话不完全准确，并且也只是其中的一点。
首先多线程提交执行速度是建立在一个基础上的，多个任务的时间执行时间是不等的，什么意思呢？比如你现在有两个任务，任务一用时10秒，任务二用时1秒，如果你顺序执行这两个任务，那么任务一需要10秒，任务二执行了1秒，但是任务二的等待时间还有10秒，所以看作是执行了11秒，这总共就是21秒的执行时间，但是如果你使用多线程呢？可能是这样子的，先执行任务一1秒，然后切换到任务二，执行任务2一秒，之后再切换回任务一，这样子的话，很明显任务二的等待时间缩短，执行时间也就更短了，相应的也就是我们的执行速度变快了。当然啦只是我自己的理解，如果你执行时间相等的话，其实切换来切换去并没有提交效率，但是这时候还是要使用多线程，为撒子？
因为多线程的另一个优点就是能够同时运行多个任务，总不可能让浏览器每次只能打开一个窗口吧，很简单，就这两个优点。
二，多线程如何使用
1.使用多线程，两种办法，很简单，第一继承Thread类，第二种实现Runnable接口，这两个种其实就是java不支持多继承，使用前者方法的话，你就不能继承其他类了，但是实现Runnable的话还是可以的，并且你也可以实现其他的接口，更为灵活一些，本质上是没有区别的，你打开Thread的源码就会发现他也是实现了Runnable接口的，另外要注意实现Runnable接口的话，一般使用时候都是实例化一个该类，用它来初始化一个Thread类，start这个start类。如下：
MyRunnable m = new MyRunnable (); //实现了Runnable接口
Thread m1 = new Thread(m);
m1.setName("我的线程");
m1.start();
2.继承之后，你需要做的就是书写run() 方法以及他的其他可能需要的方法，启动线程时使用Thread.start() ，注意使用了这个方法之后，cpu就会将这个任务加入到执行列当中去，之后根据一定规则分配资源进行调度该任务，调度该任务的意思就是执行该线程当中的 run() 方法。
3.这里一定要理解一个点，相同优先级的线程之间调度顺序是随机的，和代码顺序无关，这个就不用说了，很简单滴，不相信自己写个程序测试下就行。
三，线程安全问题，
我们一直提到线程会不安全什么的，这个不安全是这个意思：首先有一个大前提，无论你有多少个线程，这些线程都是对同一个对象进行操作或者是由同一个线程初始化的，下面这种情况会不安全：
ackage 第一章;
import javax.swing.plaf.TableHeaderUI;
class MyRunnable implements Runnable{
int count = 10;
public void run(){
count--;
System.out.println(Thread.currentThread().getName() + " " + count);
}
}
public class test1{
public static void main(String[] args){
MyRunnable m = new MyRunnable();
Thread m1 = new Thread(m, "A");
Thread m2 = new Thread(m,"B");
Thread m3 = new Thread(m,"c");
Thread m4 = new Thread(m,"D");
Thread m5 = new Thread(m,"E");
m1.start();
m2.start();
m3.start();
m4.start();
m5.start();
}
}
输出的结果每一次都是不一样的，我们期望的是count从10减到5并输出每一个数值，但是事实上的话，可能B线程已经获取到了count的值，这时候准备执行减一操作并输出，但是程序跳到A线程，执行了count--操作，B可能本来获取的值是10，之后准备count--，然后输出9，但是在这两部操作之间，count被A线程又给减一了，那么B线程获取到count的值时，就获取到了A线程更改之后的值，8，但是他原本获取到的值是9,。也就是说原本输出9，现在输出了8，这很明显是不安全的。。。。这样说不知道清楚不。输出结果如下：
"C:\Program Files\Java\jdk-11.0.1\bin\java.exe" "-javaagent:C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\lib\idea_rt.jar=60024:C:\Program Files\JetBrains\IntelliJ IDEA 2019.1.3\bin" -Dfile.encoding=UTF-8 -classpath C:\learn\java\practice\out\production\threadTest 第一章.test1
A 8
B 8
D 6
c 5
E 7
Process finished with exit code 0
下面这种情况是安全的：
就是将count变量写在run() 函数内部，让他成为局部变量，这样每一个线程虽然是由同一个对象初始化的，但是他们的count是属于各自的，你无法在A线程里更改B线程的count的值，这时候就是安全的，就这样，不难理解，这里就不放代码啦。
这里为了解决我们的不安全问题，引出了synchronized概念，
四，synchronized执行过程叙述
这个关键字其实就是给一个对象的之中的某个方法上锁，每当一个线程访问该对象的该方法时，他会首先拿到这个锁，然后开始执行里面的代码，之后如果有另一个线程再来执行同一个对象的该方法，他会先尝试拿到锁，拿不到的话就会一直等着，直到锁被释放，再拿到锁执行代码，这样子就解决了安全问题，因为相当于每一个线程进入该方法之后，就是它自己的领地了，对count变量的操作都是以它自己为标准的，其他线程不能在中途更改count的值，直到该线程执行完毕。
五，几个API：
1.CurrentThread() :获取当前线程，当前线程指的是当前代码片段是在哪一个线程上被调用的，比如下面的代码，构造函数MyRunnable() 是在main 线程当中被调用的，但是run()函数却是在线程A中调用的， 另外注意和this,getName() 的区别，后者是针对于当前this对象而言的Name
class MyRunnable implements Runnable{
int count = 10;
MyRunnable(){
System.out.println(Thread.currentThread().getName()); //输出 main
}
synchronized public void run(){
count--;
System.out.println(Thread.currentThread().getName() + " " + count); //输出 A
}
}
public class test1{
public static void main(String[] args){
MyRunnable m = new MyRunnable();
Thread m1 = new Thread(m, "A");
m1.start();
}
}
2.isAlive():当前线程是否处于活动状态，简单地说就是是否start()了并且run() 函数还没有运行完 ,用法：Thread.CurrentThread.isAlive()
3.sleep(): 让当前线程休眠一段时间，单位毫秒，注意这里这个当前线程指的是正在运行的线程，就是当前代码片段处于哪一个线程当中，注意放在try语句中，用法：Thread.sleep()
4.getId(): 获取当前线程唯一标识
六，停止线程，暂停线程
概述：停止线程简单来说就是让cpu放弃当前线程的操作，先去执行其他线程，但是如果使用不当，会有数据不同步，独占锁等问题
终止线程的方法：
1.线程run函数调用结束，自动结束
2.调用 interrupt 函数
Thread.interrupt() : 这个函数并不是说立刻停止停止线程，让线程停止操作，而是说在当前位置给线程加一个标识，表示该线程是应该停止的，但是并不会立即停止，那如果想要真正的停止该怎么办呢？使用 isTerrupted()和interrupted()，简单来讲，就是使用interrupt（）停止线程添加标识之后，再使用相应的函数判断是否存在这个停止标识，存在的话就不执行某一些代码了，这样来达到停止的效果，但是这两个函数是不同的，看下面
interrupted(): 测试当前线程是否中断，如果中断了，就将中断标识，或者说状态清除掉。简单来讲就是执行完这个函数，线程一定是处于运行状态的
isInterrupted(): 测试线程是否中断，没有清楚中断状态的功能，并且注意判断的并不是当前线程
理解两点：1，当前线程和线程的区别，2.是否会清除中断状态，
看下面例子：
Thread.interrupt() ：
class MyRunnable implements Runnable{
int count = 10;
MyRunnable(){
System.out.println(Thread.currentThread().getName());
}
public void run(){
for(int i=0;i<1000;i++)
{
System.out.println(i);
}
}
}
public class test1{
public static void main(String[] args){
MyRunnable m = new MyRunnable();
Thread m1 = new Thread(m, "A");
m1.start();
m1.interrupt(); //注释该行，不注释下一行，输出true,false
//Thread.currentThread().interrupt();
System.out.println("测试是否中断1："+Thread.interrupted()); //输出false
System.out.println("测试是否中断2："+Thread.interrupted()); //输出false
}
}
根据运行结果false来讲，我们停止了m1，线程，但是输出为false，因为调用interrupted方法代码处于的线程是main线程，main并没有停止，所以输出false，但是如果将注释去掉，将m1.interrupt()注释掉，会输出true ，false，为什么第二是false?这就是因为该函数具有清除中断状态的作用，第一次执行之后main就不再是中断状态了，所以输出false
isterrupted()方法：不具有清除状态作用，检测的是线程对象，一个具体的对象，不是当前线程，如下
package 第一章;
import javax.swing.plaf.TableHeaderUI;
class MyRunnable implements Runnable{
int count = 10;
MyRunnable(){
System.out.println(Thread.currentThread().getName());
}
public void run(){
for(int i=0;i<1000;i++)
{
System.out.println(i);
}
}
}
public class test1{
public static void main(String[] args){
MyRunnable m = new MyRunnable();
Thread m1 = new Thread(m, "A");
m1.start();
m1.interrupt();
//Thread.currentThread().interrupt();
System.out.println("测试是否中断1：&&&&&&&&&&&&&&&&&&&&&&&"+m1.isInterrupted()); //输出true
System.out.println("测试是否中断2：&&&&&&&&&&&&&&&&&&&"+m1.isInterrupted()); //输出true
}
}
都输出true，就是因为他们调用的是对象m1的，m1被停止了，所以肯定输出true，不过注意，这个true会输出在任意位置，cpu调用决定的，所以你如果测试的话加点标识找起来方便。
所以，结合来讲的话，停止线程，run方法可以修改为如下：
public void run(){
for(int i=0;i<1000;i++)
{
if(Thread.interrupted()){
System.out.println("停止啦");
break;
}
System.out.println(i);
}
//如果给这里加上语句，不判断是否停止，他还是会运行的
}
执行结果，可以看到输出了一些数字之后就停止了
。。。
205 206 207 208 209 210 211 212 停止啦 Process finished with exit code 0
当然这是一种软性的停止，你需要判断他是否停止了，下面介绍一种硬性的停止，抛出异常，很简单，将run 方法改为如下：
public void run(){
try{
for(int i=0;i<1000;i++)
{
if(Thread.interrupted()){
System.out.println("停止啦");
throw new InterruptedException();
}
System.out.println(i);
}
//for循环外面有语句也不会执行了，捕捉到异常
}catch (InterruptedException e){
e.printStackTrace();
}
}
一种情况，在沉睡中停止线程，
什么意思呢？假设你现在线程中断了，然后你再去调用Thread.sleep()函数让线程休眠，或者线程已经休眠了，你再去调用interrrupt()函数，那就会产生异常，并清除线程的中断状态。这两种情况是对立矛盾的，所以会产生异常，并且因为产生了异常，所以线程一定是被中断的
比如下面的代码，m1.start()之后，m1线程进行了sleep()，之后在main中又中断了m1线程，这明显是不合理的，所以会输出异常之中的内容
class MyRunnable implements Runnable{
int count = 10;
MyRunnable(){
System.out.println(Thread.currentThread().getName());
}
public void run(){
try{
for(int i=0;i<1000;i++)
{
System.out.println(i);
Thread.sleep(1000);
}}catch (InterruptedException e){
System.out.println("先休眠再停止");
e.printStackTrace();
}
}
}
public class test1{
public static void main(String[] args){
MyRunnable m = new MyRunnable();
Thread m1 = new Thread(m, "A");
m1.start();
try { //加这个语句是为了让m1的中断执行在睡眠之后
Thread.sleep(10);
}catch (InterruptedException e){
e.printStackTrace();
}
m1.interrupt();
}
}
输出如下：
main
0
先停止再休眠
java.lang.InterruptedException: sleep interrupted
at java.base/java.lang.Thread.sleep(Native Method)
at 第一章.MyRunnable.run(test1.java:15)
at java.base/java.lang.Thread.run(Thread.java:834)
Process finished with exit code 0
3.使用stop
这种方法已经被废除了，会造成很多问题
最简单的一个问题，数据不同步，假设你去银行，取1000，存1000，然后给你操作时候，这两个操作时在一个方法里面的，并且这个方法是上了锁的。在程序执行完了取1000之后，程序去上了个厕所，休眠了1秒，休眠期间，你使用了stop函数将线程强行停止，释放了对象锁，相当于后面存1000这个操作就没有做了，这很明显是不合理的，数据不同步了。
4.暂停线程
暂停线程是说将当前线程的操作暂停，过一会再回来继续执行，注意和中断的区别，它并不会释放对象锁
suspend()暂停函数，
resume()恢复函数
这两个函数也已经被废除了，因为可能造成独占锁和不同步的问题，废除我们也要知道他为撒子废除了，不想看的朋友可以跳过下面
独占锁问题：
不想放太多的代码，放一点，然后用文字说明，更能表达思路
有这样一个对象，比较简洁，不想写没用的代码，意思就是碰到名字为a的线程，就暂停当前线程
class test{
synchronized public void printStr() { if(Thread.currentThread().getName().equals("a")){
System.out.println("打印。。。。。"); Thread.currentThread().suspend(); } }
}
class MyRunnable implements Runnable{
int count = 10;
MyRunnable(){
System.out.println(Thread.currentThread().getName());
}
public void run() {
//调用test实例的printStr方法
}
}
现在，你初始化了a，b两个线程，使用了一个MyRunnable实例初始化的，然后你先start了a线程，a线程执行了printStr()方法，获取到了test实例的对象锁，然后被suspend了，但是它并没有释放test实例的对象锁，这时候如果b线程开启，他是无法执行printStr()方法的，因为它他拿不到对象锁，只能等着，这是不合理的。而且这里有一个有意思的问题，如果你这里使用了suspend的话，你如果想要在其他线程里面使用System.out.println() 方法，是不可以的，因为out对象的println()方法已经被锁定了。就是说你无法拿到他的锁，使用不了这个方法了，看下面的例子
class MyThread extends Thread{
private int i=0;
public void run(){
while(true){
System.out.println(i); //占用了println() 方法
i++;
}
}
}
public class test1{
public static void main(String[] args){
MyThread m = new MyThread();
m.start();
try {
Thread.sleep(10);
}catch (InterruptedException e){
e.printStackTrace();
}
m.suspend();
System.out.println("main"); //不会打印
}
}
输出结果就是打印到某一个数字然后停止，永远不会打印 main ，其实你看一下println()方法源码就明白了：里面的代码被锁住了，a线程独占了这个锁
public void println(int x) {
synchronized (this) {
print(x);
newLine();
}
}
不同步问题:
这个我觉得和前面stop的问题是一样的，不说了
七，线程的优先级
概述：前面我们看到的main线程还有自己创建的线程，代码执行都是随机的，55开滴，但是现实中线程肯定是有轻重缓急的，所以就有了线程优先级这一个概念，线程优先级高的执行的概率会大一点，但是也不是一定的，只是相对来讲大一点。
个人感觉这块没撒说的，就几个概念也都很好理解，自己写一些代码看看就行。
1.setPriotity(int ) 设置优先级
2.getPriotity() 获取优先级
3.优先级具有继承性：比如你在A线程里启动了B线程，则B线程的优先级是和A线程一样的，除非你手动进行了设置。很简单吧
4.优先级具有随机性：这个也很理解，优先级高的不一定每一次都比优先级低先执行完，因为cpu在调度的时候肯定是以概率的方式来调度线程的，概率嘛，什么都有可能，只能说样本足够大时，优先级高的一定先执行完。
八，守护线程
java里面有两种线程，用户线程和守护线程，用户线程就是我之前定义的那些，当然也包括main线程，守护线程，举一个最简单的例子，java的垃圾回收机制，它是在什么时候回收的呢？你会跟随着用于线程，有没有delete的空间了，就清除掉它，直到所有线程都结束之后，它才会自动销毁。简单来说，就是一直陪伴着用户线程，帮助用户线程做一些事情，用户线程全部结束了，它也就结束了。
设置方法：thread.setDaemon(true); 默认是false的
个人觉得可能做一些需要不停的做的事情会用到该线程。
