Java多线程知识整理

一、概念

进程-->正在进行中的程序。

迅雷下载时将一个文件拆分为5部分，是为了跟CPU争夺资源。
拆分的5部分，每一部分都称之为线程。

线程是程序中的控制单元，或者叫执行路径。
每一个进程执行都有一个执行顺序，该顺序是一个执行路径，

每一个程序打开，都会在内存中分配一块空间。
进程就是为了定义，标识这个空间的，它用于封装里面的控制单元。

线程就是进程中的一个独立的控制单元，线程在控制着进程的执行。

一个进程中至少有一个线程，线程是进程中的内容。
 
JVM 启动的时候会有一个进程Java.exe
该进程中至少有一个线程负责java程序的执行，
而且这个线程运行的代码存在与main方法中。
该线程称之为主线程。

扩展：
其实更细节说明虚拟机jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。

多线程的意义：
为了使代码同时运行，便于执行提高效率。

二、Thread类：用于描述控制单元（线程）这类事物的类。

该类定义了一个功能，用于存储线程要运行的代码，该存储功能就是run方法。
也就是说Tread类中的run方法，用于存储线程要运行的代码。

进程、线程都是由系统帮我们创建的，java已经提供好了对这种操作的描述和体现。


创建新执行线程的两种方法：
1、将类声明为Tread的子类，该子类应重写run方法。
为什么要重写run方法呢？
目的：将自定义的代码存储在run方法中，让线程运行。
2、实现Runnable接口，覆写run方法。
将Runnable接口的子类对象作为参数传递给Thread的构造函数。

实现方式和继承方式有什么区别？
继承Thread：线程代码存放在Thread子类run方法中。

实现Runnable：线程代码存在接口的子类run方法中。

实现方式的好处：避免了单继承的局限性。
在定义线程时，建立使用实现方式。

注意：如果仅仅调用run方法不能实现多线程。因为线程没有被开启。
start方法有两个作用：开启线程并执行该线程的run方法。

了解：
早期的一些病毒就是开启n多线程“抢劫”CPU资源造成死机。
多线程看似实现了程序的同时执行，其实是CPU在做着快速的切换。
多线程的特性：随机性。

了解：
多核可以实现同时执行，前提是内存得够大。


线程的四种状态：
start()sleep(time)
被创建--------->运行----------------->冻结：放弃了执行资格 
|wait()
| stop()or run方法结束
└------>消亡
第五种状态：
临时状态
阻塞：具备运行资格，但没有执行权

sleep:到时间会自动运行
wait:需要别人唤醒——notify方法


线程的方法：
|---getName()：返回线程的名称Tread-0，从0开始
|---setName()：设置线程的名称。
|---在构造中可以直接设置名称。
|---currentThread：static返回当前正在执行的线程对象


多线程存在的问题：
写多线程一定要小心安全问题。

当多条语句在操作同一个线程共享数据时，一个线程对多条语句只
执行了一部分，还没有执行完，另一个线程参与进来执行，导致共
享数据的错误。

同步：

解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。
在执行过程中，其他线程不可以参与执行。——同步代码块。

synchronized(对象){
需要被同步的代码
}


对象如同锁，持有锁的线程可以在同步中执行。
没有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

同步的前提：

1、必须要有两个或以上的线程。
2、必须是多个线程使用同一个锁。

好处：解决了多线程的安全问题，
弊端：多个线程需要判断锁，较为消耗资源。


同步出现问题怎么找：
1、明确哪些代码是多线程运行代码。
2、明确共享数据。
3、明确多线程运行代码中哪些语句是操作共享数据的。

同步函数
public synchronized void add(int i)
函数需要被对象调用，以上用同步函数的话没有传入对象，默认的就是this

注意：如果同步函数被静态修时候，使用的锁是什么呢？
反正不是this，因为静态方法中也不可以定义this。
静态进内存中，没有本类对象，但是一定有该类对应的字节吗文件对象。
类名.class 该对象的类型是class。

单例设计模式懒汉式的安全问题：

解决方案：

class Single{private static Single s=null;private Single(){}public static Single getInstance(){if(s==null){synchronized(Single.class){if(s==null){s=new Single();}}}}}

面试考点：

懒汉式的特点在于，延迟加载。
使用多线程时会出现安全隐患，可以用同步解决，但较为低效，
可以用多重判断解决这个低效问题，锁用的是该类所属的字节码文件对象。

死锁：
同步中嵌套同步，但锁不同。

死锁程序：

package Demos;public class Demo_06 {public static void main(String[] args) {new DeadLock(false).start();new DeadLock(true).start();}}class DeadLock extends Thread{private boolean flag=false;DeadLock(boolean flag){this.flag=flag;}@Overridepublic void run() {if(flag){synchronized(Lock.lockA){System.out.println("if lockA");synchronized(Lock.lockB){System.out.println("if lockB");}}}else{synchronized(Lock.lockB){System.out.println("else lockA");synchronized(Lock.lockA){System.out.println("else lockB");}}}}}class Lock{static Object lockA=new Object();static Object lockB=new Object();}

三、线程间通信

安全问题：
注意同步的几个条件要满足。

等待唤醒机制：

wait();
notify();
notifyAll();
都使用在同步中，因为要对持有监视器(锁)的线程操作。
所以要使用在同步中，因为只有同步才具有锁。

为什么这些操作线程的方法要定义Objcet类中呢？
因为这些方法在操作同步中线程时，都必须要标识它们锁操作
线程持有的锁。只有同一个锁上的被等待线程，可以被同一
个锁上的notify唤醒。不可以对不同锁中的线程进行唤醒。
也就是说，等待和唤醒必须是同一个锁。
而锁可以是任意对象，所以可以被任意对象调用的方法定义在Object类中。

线程运行的时候，内存中会建立一个线程池。
等待线程都存在线程池中。
当notify的时候都唤醒线程池中的内容。
如果线程池中存放了很多在等待的线程，notify的时候唤醒第一个等待的。

生产者消费者模式：

对于多个生产者和消费者：
为什么要定义while判断标记？
原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll？
因为需要唤醒对方线程。
只用notify，容易出现只唤醒本方线程的情况，导致程序中的所有线程都等待。

JDK5.0升级版Lock：

 提供了多线程升级解决方案。
 将同步synchronized替换成现实Lock操作。
 将Objcet中的wait，ontify，notifyAll，替换了Condition对象。
 该对象可以通过Lock锁进行获取。
  该类示例中，实现了只唤醒对方的操作。
  
  一个锁可以对应多个Condition对象。

stop方法已经过时。
如何停止线程？
只有一种，run方法结束。
开启多线程运行，运行代码通常是循环结构。
只要控制住循环，就可以让run方法结束，也就是线程结束。

特殊情况：
当线程处于冻结状态。
就不会读取到标记，那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态时，这时需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。

Thread类中提供了该方法 interrupt()：会抛出异常。程序继续运行。

setDaemon()（守护线程），在启动线程前调用，前台线程结束，守护线程也自动退出。

join()：当A线程执行到了B线程的.join()方法时，A就会等待。等B线程执行完，A才会执行。
什么时候会用：当我们在进行一个多线程运算时，一个线程在运算过程中，如果满足一个
条件，我们可以临时加入一个线程，让这个线程运算完，另外的线程再继续运行。

setPriority(int)：更改线程的优先级。所有线程默认为5。
设置优先级常量：MAX_PRIOPRITY、MIN_PRIOPRITY、NORM_PRIOPRITY

yield：临时释放，稍微减缓线程的运行。而且可以达到线程平均运行的效果。


线程组：
一般情况下，谁开启你的，你就属于哪个组。可通过ThreadGroup对象修改组。（几乎用不上

了解：
多线程也可以用匿名内部类的方式调用。