java多线程详细基础概念

1、并发与并行

当1个以上线程在操作的时候，若计算机只有一个cpu，根本不可能同时进行一个以上的处理，而是这样进行：

work1稍微操作一下暂停-->work2稍微操作一下暂停-->work1稍微操作一下暂停.....

当程序的处理像这样不断切换着操作的线程时候就被称为并发(concurrent)。

如果有一个以上cpu执行Java程序，线程操作可能就是并行的(parallel)而不是并发(concurrent)的。当一个以上线程并行操作的时候就可以同时进行一个以上的处理。

并发与并行的差异图如下：

二、线程的启动

线程的启动有两种方法：

1、利用java.lang.Thread类的子类实例，启动线程。

public class PrintThread extends Thread{    private String message;    public PrintThread(String message){        this.message = message;    }    public void run(){        for(int i = 0; i<100; i++){           System.out.print(message);        }    }}

public class Main{    public static void main(String[] args){        new PrintThread("Good").start();//匿名实例启动线程        new PrintThread("Nice").start();    }}

整个处理过程是这样：先创建PrintThread类的实例，然后调用实例的start()方法。调用start()方法的时候，会启动新的线程，然后调用实例的run()方法。上面的main()方法里只有一个语句去启动线程，不过创建线程类的实例和启动实例的线程是两个不同的处理。
当所有线程都结束时，程序才会结束。不过在判断是否结束时不包括守护线程，换句话说即使daemon thread还在，其他不是daemon thread的线程结束了，程序也就结束了。守护线程通过调用setDaemon()方法设置。

2、利用Runnable接口的实现类的实例，启动线程。

public class Printer implements Runnable{    private String message;    public Printer(Sting message){        this.message = message;    }    public void run(){        for(int i = 0; i<100;i++){            System.out.print(message);        }    }}

public class Main{    public static void main(String[] args){        new Thread(new Printer("Good")).start();        new Thread(new Printer("Nice")).start();    }}

在创建Thread类的实例的时候，输出Printer类的实例作为构造器的参数(Runnable target)，然后利用start()方法启动线程。

无论是那种方法，启动线程的永远都是Thread类的start()方法。

三、线程的暂停

Thread.sleep(1000);

这行代码可以让当前的线程（执行这条语句的线程暂停约1000ms），这个方法要放在try-catch里面，因为sleep方法可能会抛出一个InterruptedException的异常，这个异常用在取消线程处理时的异常。

Thread.sleep(ms,ns);可以将时间控制得更精细，达到ns(10^(-9)s)。

四、线程的共享互斥

当多个线程访问同一个资源的时候，会出现一些和预想情况不符合的现象，这时候就需要“共享互斥”或者说“互斥控制”，Java在处理线程的共享互斥的时候，通常会使用关键字synchronized。

1、使用synchronized关键字修饰类的方法。

public class Test{    public synchronized void test(){        //to do    }}

当一个线程执行Test实例的test方法时，其他线程就不能执行同一个实例test方法，对于同一个类里的非synchronized方法没有这个限制，对于同一个实例，多个线程可以同时访问。对于某个正在执行test方法的线程，当执行完test方法后，锁就会被释放(release)。当锁被释放之后，其他在等待的多个线程便开始抢锁，一定有且只有一个线程会获得锁，没有抢到就继续等待。

线程共享互斥的架构被称为监视（monitor），而获取锁有时也被称为持有（own）监视。

2、使用synchronized关键字修饰方法里的一部分（synchronized阻挡），格式如下：

synchronized(表达式){    //to do}

对于synchronized实例方法和synchronized阻挡：

synchronized void method(){    //to do}

和下面这个synchronized阻挡效果是一样的：

void method(){    synchronized(this){        //to do    }}

换句话说，synchronized实例方法是使用this锁去做线程的互斥共享。

对于synchronized类静态方法和synchronized阻挡：

class Something{    static synchronized void method(){         //to do    }}

和下面这个synchronized阻挡效果是是一样：

class Something{    static void method(){        synchronized(Something.class){            //to do        }    }}

换句话说，synchronized类静态方法和使用该类的类对象的锁去做线程的共享互斥。

五、线程的协调

wait set----线程休息室

wait set是一个在执行该实例的wait方法时，操作停止时的线程集合，每个实例都有。

wait set实际上是一个虚拟的概念，不是实例的字段，也不是可以获取在实例上wait中线程的列表的方法。

一旦执行wait方法，线程便暂停操作，进入wait set，除非发生下面任何一种情况，否则线程永远留在这个wait set里：

1、有其他线程使用notify方法唤醒该线程；

2、有其他线程使用notifyAll方法唤醒该线程；

3、有其他线程使用interrupt方法唤醒该线程；

4、wait方法已到期。

wait方法----把线程放入wait set

使用wait方法后，线程进入wait set，如obj.wait();

当在实例内的时候直接执行wait()即可，等同于this.wait();

执行wait()方法的时候，线程需要获得锁，当线程进入wait set之后，已经释放了该实例的锁。

当线程A执行wait()方法时线程B仍然无法获得锁

当线程A执行了wait()方法之后，线程A进入了wait set，然后释放了锁。

线程B获得了锁，开始执行synchronized修饰的方法。

notify方法----从wait set中拿出线程

使用notify方法的时候，可以从wait set中抓取一个线程，唤醒这个线程，被唤醒的线程便退出wait set。

线程B执行notify方法唤醒线程A。

线程A退出wait set，打算执行自己wait()的下面的操作，但是刚才执行notify的线程B仍然握着锁不放手。

刚才执行过notify的线程B开始释放锁。

已经退出wait set的线程A获得锁，开始执行wait下面的操作。

线程需要有遇到用实例的锁，才能执行notify方法。

tips:

1、从上面的图也可以看出来，被notify唤醒的线程不是在notify的一瞬间重新开始执行，因为在notify的那一刻，执行notify的线程还握着锁不妨，所以其他线程无法获取该实例的锁。

2、假设执行notify方法的时候，wait set里正在等待的线程不止1个，规格里并没有注明应该选择哪个线程，依据Java处理系统而异，因此，最好不要将程序写成因所选线程而有所改动。

notifyAll方法----从wait set中拿出所有线程

使用notifyAll方法时，会将所有在wait set里的线程拿出来。

线程同样需要有欲调用实例的锁，才能调用notifyAll方法，否则会抛出IlleagalMonitorStateException。

tips:选择notify还是notifyAll?

选择notify的话，要唤醒的线程少，速度比notifyAll要好，但是选择notify若处理不慎有可能导致程序挂掉，因此notifyAll方法更可靠。当然能处理好的话，notify更好。

另外，wait,notify,notifyAll方法都是Object类下的方法，不是Thread下的。

六、线程的状态转移