Java并发入门

[jingegebuguai]

可以说并发是Java开发工程师面试时最常见的面试题了，关于并发的书籍也有很多，比如Java并发编程实战，Java并发编程艺术等。下面的几篇文章目的用最浅显的内容来解释并发的基础内容、并发的三大特性、线程池、并发容器、锁机制、相关源码分析等内容。并且会在每一篇章最后总结出常见的面试题。

进程？线程？

这可以说是操作系统中的一块问题，也是Java并发编程的开始。首先来看看基本概念：

• 进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,进程是系统进行资源分配和调度的一个独立单位.
• 线程是进程的一个实体,是CPU调度和分派的基本单位,它是比进程更小的能独立运行的基本单位.线程自己基本上不拥有系统资源,只拥有一点在运行中必不可少的资源(如程序计数器,一组寄存器和栈),但是它可与同属一个进程的其他的线程共享进程所拥有的全部资源.

如果实在无法理解，可以去看看阮一峰老师的解释：
一个比较有趣的进程，线程的解释

二者区别：

• 进程：进程有独立的代码和数据空间，进程间的切换会有较大的开销，每个进程可以包含多个线程。
• 线程：多个线程可以共享代码和数据空间，每个线程有独立的运行栈和PC，切换开销较小。

二者相同点：
执行阶段：创建，就绪，运行，阻塞，终止。

主线程

通常运行一个java程序，就会有一个线程立即运行，这个线程就是主线程。

• 是产生其他子线程的线程
• 通常最后完成，执行各种关闭动作（后面会发现不做处理，它也会提前完成）

尽管主线程在程序启动时自动创建，但它可以由一个Thread对象控制。为此，你必须调用方法currentThread()获得它的一个引用，currentThread()是Thread类的公有的静态成员。它的通常形式如下：

static Thread currentThread( )

该方法返回一个调用它的线程的引用。一旦你获得主线程的引用，你就可以像控制其他线程那样控制主线程。

	class CurrentThreadDemo {
	    public static void main(String args[]) {
	        Thread t = Thread.currentThread();
	        System.out.println("Current thread: " + t);
	        // change the name of the thread
	        t.setName("My Thread");
	        System.out.println("After name change: " + t);
	        try {
	            for(int n = 5; n > 0; n--) {
	                System.out.println(n);
	                Thread.sleep(1000);
	            }
	        } catch (InterruptedException e) {
	            System.out.println("Main thread interrupted");
	        }
	    }
	}

输出如下：

Current thread: Thread[main,5,main]
After name change: Thread[My Thread,5,main]
5
4
3
2
1

我们输出的线程显示顺序依次是[线程名称，优先级，组的名称]。主线程名称默认为main，优先级为5，main为组的名称。
我们可以用setName()设置线程的名称，用getName()获取线程的名称。

	final void setName(String threadName)
	final String getName()

## Thread类

	class testThread extend Thread{
		private String name;
		public testThread(){
			this.name = name;
		}
		public void run(){
			for(int i=0;i<5;i++){
				System.out.println(name+"running: "+i);
			}try{
				sleep((int) Math.random()*10);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
	public class Main{
		public static void main(String[] args){
			testThread thread_1 = new testThread("A");
			testThread thread_2 = new testThread("B");
			thread_1.start();
			thread_2.start();
		}
	}

运行结果如下：

B running: 0
A running: 0
B running: 1
B running: 2
A running: 1
B running: 3
A running: 2
A running: 3
A running: 4
B running: 4

在start()方法后，并不是立即执行多线程代码，而是使线程进入可运行状态（Runnable），何时运行由操作系统决定。由于代码执行时乱序的，所以我们要加上线程机制。

Runnable接口

	import static java.lang.Thread.sleep;
	class testThread implements Runnable{
	    private String name;
	    public testThread(String name){
	        this.name = name;
	    }
	    public void run(){
	        for (int i=0;i<5;i++){
	            System.out.println(name+" running: "+i);
	        }try{
	            Thread.sleep((int)Math.random()*10);
	        }catch (InterruptedException e){
	            e.printStackTrace();
	        }
	    }
	}
	public class Main{
	    public static void main(String[] args) {
	        testThread thread_1 = new testThread("C");
	        testThread thread_2 = new testThread("D");
	        new Thread(thread_1).start();
	        new Thread(thread_2).start();
	    }
	}

运行结果：

C running: 0
C running: 1
C running: 2
C running: 3
C running: 4
D running: 0
D running: 1
D running: 2
D running: 3
D running: 4

在启动线程时，需要先通过Thread类的构造方法Thread类的构造方法Thread构造出对象，然后调用Thread对象的start()方法来运行多线程代码。
注意Thread和Runnable之间代码具有细微的差别，但是二者背后的差距很大。

Thread类和Runnable接口区别

实现Runnable接口比继承Thread类所具有的优势：
1）：适合多个相同的程序代码的线程去处理同一个资源
2）：可以避免java中的单继承的限制
3）：增加程序的健壮性，代码可以被多个线程共享，代码和数据独立
4）：线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

线程状态转化图

1. 新建(new)：新创建了一个线程对象。

2. 可运行(runnable)：线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取cpu 的使用权 。

3. 运行(running)：可运行状态(runnable)的线程获得了cpu 时间片（timeslice） ，执行程序代码。

4. 阻塞(block)：阻塞状态是指线程因为某种原因放弃了cpu 使用权，也即让出了cpu timeslice，暂时停止运行。直到线程进入可运行(runnable)状态，才有机会再次获得cpu timeslice 转到运行(running)状态。阻塞的情况分三种：

(一). 等待阻塞：运行(running)的线程执行o.wait()方法，JVM会把该线程放入等待队列(waitting queue)中。

(二). 同步阻塞：运行(running)的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池(lock pool)中。

(三). 其他阻塞：运行(running)的线程执行Thread.sleep(long ms)或t.join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入可运行(runnable)状态。

5. 死亡(dead)：线程run()、main() 方法执行结束，或者因异常退出了run()方法，则该线程结束生命周期。死亡的线程不可再次复生。

常用函数

sleep()

最简单的一个函数，作用是在指定的毫秒数内瓤当前正在执行的线程进入休眠，也就是进入阻塞状态。另外它没有对象锁这个概念。

join()

join是Thread类的一个方法，启动线程后直接调用，即join()的作用是：“等待该线程终止”，这里需要理解的就是该线程是指的主线程等待子线程的终止。也就是在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。
在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用到join()方法了。
不加join。
看如下示例（不加join函数的情况）：

	import static java.lang.Thread.sleep;
	class testThread implements Runnable{
	    private String name;
	    public testThread(String name){
	        this.name = name;
	    }
	    public void run(){
	        System.out.println(Thread.currentThread().getName()+" 线程开始运行");
	        for(int i=0;i<5;i++) {
	            System.out.println(name + " running " + i);
	            try {
	                sleep((int) Math.random() * 10);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
	        System.out.println(Thread.currentThread().getName()+" 线程运行结束");
	    }
	}
	public class Main{
	    public static void main(String[] args) {
	        System.out.println(Thread.currentThread().getName()+ " 主线程开始运行");
	        new Thread(new testThread("E")).start();
	        new Thread(new testThread("F")).start();
	        System.out.println(Thread.currentThread().getName()+ " 主线程运行结束");
	    }
	}

运行结果如下：

main 主线程开始运行
main 主线程运行结束
Thread-0 线程开始运行
Thread-1 线程开始运行
E running 0
F running 0
E running 1
F running 1
E running 2
F running 2
E running 3
F running 3
E running 4
F running 4
Thread-0 线程运行结束
Thread-1 线程运行结束

我们想让主线程最后执行完，下面再看看加上join（）的情况：

	import static java.lang.Thread.sleep;
	class testThread implements Runnable{
	    private String name;
	    public testThread(String name){
	        this.name = name;
	    }
	    public void run(){
	        System.out.println(Thread.currentThread().getName()+" 线程开始运行");
	        for(int i=0;i<5;i++) {
	            System.out.println(name + " running " + i);
	            try {
	                sleep((int) Math.random() * 10);
	            } catch (InterruptedException e) {
	                e.printStackTrace();
	            }
	        }
	        System.out.println(Thread.currentThread().getName()+" 线程运行结束");
	    }
	}
	public class Main{
	    public static void main(String[] args) {
	        System.out.println(Thread.currentThread().getName()+ " 主线程开始运行");
	        Thread thread_1 = new Thread(new testThread("E"));
	        Thread thread_2 = new Thread(new testThread("F"));
	        thread_1.start();
	        thread_2.start();
	        try{
	            thread_1.join();
	        }catch (InterruptedException e){
	            e.printStackTrace();
	        }
	        try{
	            thread_2.join();
	        }catch (InterruptedException e){
	            e.printStackTrace();
	        }
	        System.out.println(Thread.currentThread().getName()+ " 主线程运行结束");
	    }
	}

运行结果如下：

main 主线程开始运行
Thread-0 线程开始运行
E running 0
Thread-1 线程开始运行
F running 0
E running 1
F running 1
E running 2
F running 2
E running 3
F running 3
E running 4
F running 4
Thread-0 线程运行结束
Thread-1 线程运行结束
main 主线程运行结束		

yield()

作用是暂停当前的执行的线程对象，开始执行其他线程。
需要注意的是yield()是让当前运行状态进入到可运行状态，而非阻塞状态，实际情况下，我们并无法保证yield()完美的完成让步目的，即使当前线程让步了，根据优先级，该线程还可能继续被选中，继续执行该线程。由于可控性差的原因，建议尽量少用yield()函数。

sleep()和yield()的区别：

sleep()和yield()的区别):sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
sleep 方法使当前运行中的线程睡眼一段时间，进入不可运行状态，这段时间的长短是由程序设定的，yield 方法使当前线程让出 CPU 占有权，但让出的时间是不可设定的。实际上，yield()方法对应了如下操作：先检测当前是否有相同优先级的线程处于同可运行状态，如有，则把 CPU 的占有权交给此线程，否则，继续运行原来的线程。所以yield()方法称为“退让”，它把运行机会让给了同等优先级的其他线程
另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield() 方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。在一个运行系统中，如果较高优先级的线程没有调用 sleep 方法，又没有受到 I\O 阻塞，那么，较低优先级线程只能等待所有较高优先级的线程运行结束，才有机会运行。

wait()&notify()

wait()和notify()必须和synchronized一起使用，二者针对对象进行操作。wait()必须在同步代码块中调用，调用wait()的线程会等待，知道其他线程调用了notify()方法之后，该线程才会被唤醒。被唤醒并不意味着立即获得对象锁，需要等待两件事的发生：

• 有其他线程调用同一个对象的notify或者notifyAll方法（调用notify/notifyAll方法之前）
• 被唤醒之后重新获得对象的锁(调用notify/notifyAll方法之后)才能继续往下执行后续动作。

	import java.util.concurrent.TimeUnit;
	public class Main{
	    public static Object object = new Object();
	    static class testThread_1 implements Runnable{
	        @Override
	        public void run()
	        {
	            synchronized(object)
	            {
	                System.out.println(Thread.currentThread().getName()+" running.");
	                try
	                {
	                    object.wait();
	                }
	                catch (InterruptedException e)
	                {
	                    e.printStackTrace();
	                }
	                System.out.println(Thread.currentThread().getName()+" get the lock.");
	            }
	        }
	    }
	    static class testThread_2 implements Runnable{
	        @Override
	        public void run() {
	            synchronized (object){
	                System.out.println(Thread.currentThread().getName()+ " running");
	                object.notify();
	                System.out.println(Thread.currentThread().getName()+ " is invoked");
	                System.out.println(Thread.currentThread().getName()+ "release the lock");
	            }
	        }
	    }
	    public static void main(String[] args)throws InterruptedException {
	        new Thread(new testThread_1()).start();
	        TimeUnit.SECONDS.sleep(1);
	        new Thread(new testThread_2()).start();
	    }
	}

运行结果如下：

Thread-0 running.
Thread-1 running
Thread-1 is invoked
Thread-1release the lock
Thread-0 get the lock.

其他函数

• activeCount 返回当前线程的线程组中活动线程的个数
• checkAccess 判断当前运行的线程是否有更改当前线程的权限
• currentThread 返回当前线程
• dumpStack 输出当前线程的堆栈跟踪信息到标准错误输出流
• enumerate 复制当前线程的线程组和子线程组中的活动线程到指定数组
• getAllStackTraces 返回所有活动线程对应的堆栈信息
• getContextClassLoader 返回当前线程的上下文类装载器
• getDefaultUncaughtExceptionHandler 返回线程因未捕获的例外非正常终止时调用的默认处理程序
• getId 返回线程的标识符
• getName 返回线程的名称
• getPriority 返回线程的优先级
• getStackTrace 返回线程的堆栈数组
• getState 返回当前线程的状态
• getThreadGroup 返回线程所属的线程组
• getUncaughtExceptionHandler 返回线程因未捕获的例外非正常终止时调用的处理程序
• holdsLock 当前线程拥有指定对象的监控器锁时，返回true
• interrupt 中断这个线程
• interrupted 判断当前线程是否已经中断
• isAlive 判断当前线程是否处于活动状态
• isDaemon 判断这个线程是否守护线程
• isInterrupted 判断当前进程是否已经中断
• run 线程的运行代码
• setContextClassLoader 设置当前线程的上下文类装载器
• setDaemon 设置当前线程为守护线程
• setDefaultUncaughtExceptionHandler 设置线程因未捕获的例外非正常终止时调用的默认处理程序
• setName 更改线程的名字
• setPriority 更改线程的优先级
• setUncaughtExceptionHandler 设置线程因未捕获的例外非正常终止时调用的处理程序
• start 当前线程开始执行
• toString 返回当前线程的字符串表示

总结

这一块基本都是Java入门书籍中都会出现的知识点，当然真的是入门。其中，Thread类和Runnable接口之间的区别是面试最常见的题目。线程同步部分在后面的章节结合synchronized一起叙述。下面一个章节将结合Java并发编程实战这本书来谈谈并发三大特性的相关机制和volatile的相关基础。