Java并行程序基础

thread t1 = new thread(()->{

int i = 1;

while (true) {

if (thread.currentthread().isinterrupted()) {

system.out.println("interrupt!");

break;

}

system.out.println("i'm working " + i++);

thread.yield();

});

t1.start();

thread.sleep(2000);

t1.interrupt();

这看起来跟前面增加标志位的手法非常相似，但是中断的功能更为强劲。比如，如果在循环体中，出现了类似于wait()或者sleep()这样的操作，则只能通过中断来识别了。

线程的睡眠sleep

==========

public static native void sleep(long millis) throws interruptedexception;

?该方法会让当前线程休眠若干时间，会抛出interruptedexception中断异常。interruptedexception不是运行时异常，也就是程序必须捕获并且处理它，当线程在sleep休眠时，如果被中断，这个异常就会发生。

public static void main(string[] args) throws interruptedexception {

try {

} catch (interruptedexception e) {

system.out.println("interrupted when sleep");

thread.currentthread().interrupt();

thread.sleep(1000);

如果在sleep的时候，线程被中断，则程序会抛出异常，并进入异常处理。在catch字句里，由于已经捕获了中断，我们可以立即退出线程，但是并没有这么做。因为也许在这段代码中，还必须进行后续的处理，保障数据的一致性和完整性。因此，执行了interrupt()方法再次中断自己，置上中断标志位。只有这么做，在检查isinterrupted()，才能发现当前线程已经被中断了。可以试一下将catch的interrupt注释掉进行验证。

thread.sleep()方法由于中断而抛出异常，此时，它会清除中断标记，如果不加处理，那么在下一次循环开始时，就无法不会这个中断，所以在异常处理中，再次设置中断标志位。

等待（wait）和通知（notify）

===================

wait和notify不是在thread类中的方法，而是在object类中，意味着任何对象都能调用这两个方法。

如果一个线程调用了wait()方法，那么它就会计入object对象的等待队列。这个等待队列中，可能会有多个线程，因为系统运行多个线程同时等待同一个对象。当notify()被调用是，它就会从这个等待队列中，随机选择一个线程，并将其唤醒。但是这个选择不是公平的，并不是先等待的线程会优先被选择，这个选择完全是随机的。

notifyall()方法会唤醒这个等待队列的所有线程。

无论是wait()或者是notify()方法，必须包含在对应的synchronized语句中，无论是wait()或者notify()都需要首先获取目标对象的一个监视器。

而wait()方法执行后，会释放这个监视器，当被重新notify()后，要做的第一件事不是继续执行后续的代码，而是要尝试重新获取object的监视器。如果暂时无法获得，线程还必须要等待这个监视器。当监视器顺利获得后，才可以真正意义上的继续执行。

wait()方法和sleep()的区别就是，wait会释放对象的锁，而sleep不会释放锁。

挂起（suspend）和继续执行（resume）

========================

被挂起的线程必须要等到resume操作后，才能继续指定、

但是已经被标注为废弃方法，不推荐使用。因为suspend()在导致线程暂停的同时，并不会去释放任何资源。此时，任何线程想要访问被它暂用的锁，都会备受牵连，导致无法正常运行。直到对应的线程上进行了resume()操作，被挂起的线程才能继续操作。但是如果resume操作在suspend之前就执行了，那么被挂起的线程就很难有机会被继续执行了。

如果想要实现suspend跟resume，可以通过wait跟notify进行使用。

等待线程结束（join）和谦让（yield）

==========================

一个线程的输入可能非常依赖于另外一个或者多个线程的输出，所以，这个线程就需要等待依赖线程执行完毕，才能继续执行。

public final void join() throws interruptedexception

public final synchronized void join(long millis) throws interruptedexception

第一个join()方法表示无限等待，它会一直阻塞当前线程，知道目标线程执行完毕。

第二个join()给出了一个最大等待时间，如果超过给定时间目标线程还在执行，当前线程也会因为“等不及”，而继续往下执行。

join就是加入的意思，因此一个线程要加入另外一个线程，那么最好的方法就是等着它一起走。

public class joinmain {

public volatile static int i = 0;

public static class addthread extends thread {

@override

public void run() {

for (i = 0; i < 1000000; i++);

addthread at =

new addthread();

at.start();

at.join();

system.out.println(i);

主函数中，如果不用join()等待addthread,那么得到的i很可能是0或者一个非常小的数字。因为addthread还没执行完，i的值就已经被输出了。但使用join方法后，表示主线程愿意等待addthread执行完毕，跟着addthread一起往前走，所以在join()返回，addthread已经执行完成，故i总是1000000；

join的本质是让调用线程wait()在当前线程对象实例上。

if (millis == 0) {

while (isalive()) {

wait(0);

可以看到，它调用线程在当前线程对象上进行等待。当执行完成后，被等待的线程会在退出前调用notifyall()通知所有的等待线程继续执行。

因此需要注意，不要在应用程序中，在thread对象上使用类似wait()或者notify()等方法，因为这很有可能影响系统api的工作，或者被系统api所影响。

public static native void yield();

yield()这是个静态方法。一旦执行，它会使当前线程让出cpu。当前线程让出cpu后，还会进行cpu资源的争夺，但是是否能被再次分配到，就不一定了。

???????volatile与java内存模型（jmm）

=================================

???????java内存模型都是围绕着原子性，有序性，可见性展开。

java使用了一些特殊的操作或者关键字来什么，告诉虚拟机，在这个地方，尤其注意，不能随意变动优化目标指令。volatile就是其中之一。

volatile：易变的，不稳定的。

当volatile去申明一个变量，就等于告诉虚拟机。这个变量极有可能会被某些线程修改。为了确保这个变量被修改后，应用程序范围内所有线程都能够“看到”。虚拟机就必须采用一些特殊的手段，保证这个变量的可见性等特点。

volatile并不能替代锁。也无法保证一些符合操作的原子性。volatile无法保证i++原子性操作。

volatile能保障数据的可见性和有序性。

???????守护线程（daemon）

=======================

???????守护线程是一种特殊的线程，是系统的守护者，在后台默默地完成一些系统性的服务。比如垃圾回收线程，jit线程就可以理解为守护线程。

线程的优先级

======

java使用1~10表示线程优先级。数字越大优先级越高。**???????**

同步方法以及同步块

=========

线程同步

由于同一进程的多个线程共享同一块存储空间，在带来方便的同时，也带来了访问冲突问题，为了保障数据在方法中被访问时的正确性，在访问时加入锁机制synchronized，当一个线程获得对象的排他锁，独占资源，其他线程必须等待，使用后是否锁即可。但是存在以下问题：

一个线程持有锁会导致其他所有需要此锁的线程挂起。

在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题

如果一个优先级高的线程等待一个优先级低的线程释放锁，会导致优先倒置，引起性能问题。

关键字synchronized的作用是实现线程间的同步。它的工作是对同步的代码加锁，使得每一次，只能有一个线程进入同步块，从而保证线程间的安全性。

指定加锁对象：对给定对象加锁，进入同步代码前要获得给定对象的锁。

直接作用于实例方法：相当于对当前实例加锁，进入同步代码前要获得当前实例的锁。

直接作用于静态方法：相当于对当前类加锁，进入同步代码块要获得当前类的锁。

synchronized除了保证线程同步，还可以保证线程之间的可见性和有序性。从可见性上来说，synchronized可以完全代替volatile，只是使用上没那么方便。就有序性而言，由于synchronized限制每次只有一个线程可以访问同步块，无论同步块内的代码如何被乱序执行，只要保证串行语义一致性，那么执行结果总是一样的。

同步方法

可以通过private关键字来保证数据对象只能被方法访问，所以只需要针对方法提出一套机制，这套机制就是synchronized关键字。有synchronized方法和synchronized块

synchronized方法控制对“对象”的访问，每个对象对应一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就会独占该锁，直到方法返回才释放锁，后面被阻塞的线程才能获得这个锁，继续执行

缺陷：若将一个大的方法申明为synchronized将会影响效率。

同步块

同步块：synchronized（obj）{}

obj 称之为?同步监视器

obj可以使任何对象，推荐使用共享资源作为同步监视器

同步方法中无需指定同步监视器，因为同步方法的同步监视器就是this，就是这个对象本身，或者是class

同步监视器的执行过程

第一个线程访问，锁定同步监视器，执行其中代码

第二个线程访问，返现同步监视器被锁定，无法访问