Java语法进阶11-多线程

多线程

并发与并行、进程，线程调度自行百度

线程（thread）：是一个进程中的其中一条执行路径，CPU调度的最基本调度的单位。同一个进程中线程能够共享一些内存（堆、方法区），每个线程又有本身的独立空间（栈、程序计数器）。由于线程之间有共享的内存，在实现数据共享方面，比较方便，可是又由于共享数据的问题，会有线程安全问题。

当运行Java程序时，其实已经有一个线程了，那就是main线程。

Thread类

全部的线程对象都必须是Thread类或其子类的实例，Java中经过继承Thread类来建立并启动多线程的步骤以下：

1. 定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就表明了线程须要完成的任务,所以把run()方法称为线程执行体。

2. 建立Thread子类的实例，即建立了线程对象

3. 调用线程对象的start()方法来启动该线程

Runnable接口

咱们还能够实现Runnable接口，重写run()方法，而后再经过Thread类的对象代理启动和执行咱们的线程体run()方法。步骤以下：

1. 定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体一样是该线程的线程执行体。

2. 建立Runnable实现类的实例，并以此实例做为Thread的target来建立Thread对象，该Thread对象才是真正 的线程对象。

3. 调用线程对象的start()方法来启动线程。

例： public class MyRunnable implements Runnable　　//定义实现线程类

  　　MyRunnable mr = new MyRunnable();　　　　　//建立线程对象

         Thread t = new Thread(mr);　　　　　　　　　//经过Thread类的实例，启动线程
          t.start();

实际上全部的多线程代码都是经过运行Thread的start()方法来运行的。所以，不论是继承Thread类仍是实现 Runnable接口来实现多线程，最终仍是经过Thread的对象的API来控制线程的，熟悉Thread类的API是进行多线程编程的基础。

tips:Runnable对象仅仅做为Thread对象的target，Runnable实现类里包含的run()方法仅做为线程执行体。 而实际的线程对象依然是Thread实例，只是该Thread线程负责执行其target的run()方法。

两种方式的区别

一、继承的方式有单继承的限制，实现的方式能够多实现

二、启动方式不一样

三、继承：在实现共享数据时，可能须要静态的

　　实现：只要共享同一个Runnable实现类的对象便可。

四、继承：选择锁时this可能不能用，

　　实现：选择锁时this能够用。

匿名内部类对象来实现线程的建立和启动

new Thread("新的线程！"){
　　@Override
　　public void run() {
　　　　for (int i = 0; i < 10; i++) {
　　　　　　System.out.println(getName()+"：正在执行！"+i);
　　　　}
　　}
}.start();

构造方法

public Thread() :分配一个新的线程对象。

public Thread(String name) :分配一个指定名字的新的线程对象。

public Thread(Runnable target) :分配一个带有指定目标新的线程对象。

public Thread(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。

线程经常使用方法

volatile：修饰变量

变量不必定在何时值就会被修改了，为了老是获得最新的值，volatile修饰以后那么每次都从主存中去取值，不会在寄存器中缓存它的值。

守护线程

守护线程有个特色，就是若是全部非守护线程都死亡，那么守护线程自动死亡。

调用setDaemon(true)方法可将指定线程设置为守护线程。必须在线程启动以前设置，不然会报IllegalThreadStateException异常。

调用isDaemon()能够判断线程是不是守护线程。

线程安全

线程安全问题的判断

一、是否有多个线程

二、这多个线程是否使用共享数据

三、这些线程在使用共享数据时，是否有写有读操做

同步代码块

synchronized 关键字能够用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问。 格式:

synchronized(同步锁){
     须要同步操做的代码
}

同步锁必须是对象

锁对象能够是任意类型。

多个线程对象必须使用同一把锁。 注意:在任什么时候候,最多容许一个线程拥有同步锁,谁拿到锁就进入代码块,其余的线程只能在外等着(BLOCKED)。

同步方法

使用synchronized修饰的方法,就叫作同步方法,保证持有锁线程执行该方法的时候,其余线程只能在方法外等着

【其余修饰符】 synchronized 返回值类型 方法名(【形参列表】)【throws 异常列表】{
    　//可能会产生线程安全问题的代码
}

锁对象不能由咱们本身选，它是默认的：

（1）静态方法：锁对象是当前类的Class对象

（2）非静态方式：this

线程间通讯

当“数据缓冲区”满的时候，“生产者”须要wait，等着被唤醒；

当“数据缓冲区”空的时候，“消费者”须要wait，等着被唤醒。

在一个线程知足某个条件时，就进入等待状态（wait()/wait(time)）， 等待其余线程执行完他们的指定代码事后再将其唤醒（notify()）;或能够指定wait的时间，等时间到了自动唤醒；在有多个线程进行等待时，若是须要，可使用 notifyAll()来唤醒全部的等待线程。

1. wait：线程再也不活动，再也不参与调度，进入 wait set 中，所以不会浪费 CPU 资源，也不会去竞争锁了，这时的线程状态便是 WAITING或TIMED_WAITING。它还要等着别的线程执行一个特别的动做，也便是“通知（notify）”或者等待时间到，在这个对象上等待的线程从wait set 中释放出来，从新进入到调度队列（ready queue）中

2. notify：则选取所通知对象的 wait set 中的一个线程释放；

3. notifyAll：则释放所通知对象的 wait set 上的所有线程。

注意：

被通知线程被唤醒后也不必定能当即恢复执行，由于它当初中断的地方是在同步块内，而此刻它已经不持有锁，因此她须要再次尝试去获取锁（极可能面临其它线程的竞争），成功后才能在当初调用 wait 方法以后的地方恢复执行。

总结以下：

• 若是能获取锁，线程就从 WAITING 状态变成 RUNNABLE（可运行） 状态；

• 不然，线程就从 WAITING 状态又变成 BLOCKED（等待锁） 状态

调用wait和notify方法须要注意的细节

1. wait方法与notify方法必需要由同一个锁对象调用。由于：对应的锁对象能够经过notify唤醒使用同一个锁对象调用的wait方法后的线程。

2. wait方法与notify方法是属于Object类的方法的。由于：锁对象能够是任意对象，而任意对象的所属类都是继承了Object类的。

3. wait方法与notify方法必需要在同步代码块或者是同步函数中使用。由于：必需要经过锁对象调用这2个方法。

等待唤醒机制能够解决经典的“生产者与消费者”的问题

要解决该问题，就必须让生产者线程在缓冲区满时等待(wait)，暂停进入阻塞状态，等到下次消费者消耗了缓冲区中的数据的时候，通知(notify)正在等待的线程恢复到就绪状态，从新开始往缓冲区添加数据。反之亦然

线程生命周期

1、站在线程的角度上：5种

一、新建：建立了线程对象，还未start

二、就绪：已启动，而且可被CPU调度

三、运行：正在被调度

四、阻塞：遇到了：sleep(),wait(),wait(time),其它线程的join()，join(time)，suspend()，锁被其余线程占用等

　　解除阻塞回到就绪状态：sleep()时间，notify()，wait的时间到，加塞的线程结束，加塞的时间到，resume()，其余占用锁的线程释放了锁等。

五、死亡：run()正常结束，遇到了未处理的异常或错误，stop()

注意：

程序只能对新建状态的线程调用start()，而且只能调用一次，若是对非新建状态的线程，如已启动的线程或已死亡的线程调用start()都会报错IllegalThreadStateException异常。

2、站在代码的角度上6种

在java.lang.Thread.State的枚举类中这样定义

public enum State {
　　NEW,
　　RUNNABLE,
　　BLOCKED,
　　WAITING,
　　TIMED_WAITING,
　　TERMINATED;
}

一、新建NEW：建立了线程对象，还未start

二、可运行RUNNABLE：能够被CPU调度，或者正在被调度

三、阻塞BLOCKED：等待锁

四、等待WAITING：wait(),join()等没有设置时间的，必须等notify()，或加塞的线程结束才能恢复

五、有时间等待TIMED_WAITING：sleep(time)，wait(time)，join(time)等有时间的阻塞，等时间到了恢复，或被interrupt也会恢复

六、终止TERMINATED：run()正常结束，遇到了未处理的异常或错误，stop()

释放锁操做与死锁

任何线程进入同步代码块、同步方法以前，必须先得到对同步监视器的锁定，那么什么时候会释放对同步监视器的锁定呢？

一、释放锁的操做

当前线程的同步方法、同步代码块执行结束。

当前线程在同步代码块、同步方法中出现了未处理的Error或Exception，致使当前线程异常结束。

当前线程在同步代码块、同步方法中执行了锁对象的wait()方法，当前线程被挂起，并释放锁。

二、不会释放锁的操做

线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行。

线程执行同步代码块时，其余线程调用了该线程的suspend()方法将该线程挂起，该线程不会释放锁（同步监视器）。应尽可能避免使用suspend()和resume()这样的过期来控制线程。

三、死锁

不一样的线程分别锁住对方须要的同步监视器对象不释放，都在等待对方先放弃时就造成了线程的死锁。一旦出现死锁，整个程序既不会发生异常，也不会给出任何提示，只是全部线程处于阻塞状态，没法继续。