Java多线程总结

一、Java实现多线程的三种方法

 

1、  扩展java.lang.Thread类

2、  实现java.lang.Runnable接口

3、  实现java.util.concurrent.Callable接口

public class MyCallable implements Callable<Integer> {

	Integer a;
	Integer b;
	public MyCallable(Integer a, Integer b) {
		super();
		this.a = a;
		this.b = b;
	}

	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		return a + b;
	}

	public static void main(String[] args) {
		Callable<Integer> callable = new MyCallable(4, 3);
		FutureTask f = new FutureTask<>(callabe);
		new Thread(f).start();
		try {
			System.out.println(f.get());
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (ExecutionException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

和Runnable接口不一样，Callable接口提供了一个call（）方法作为线程执行体，call()方法比run()方法功能要强大。

1) call()方法可以有返回值

2) call()方法可以声明抛出异常

Java5提供了Future接口来代表Callable接口里call()方法的返回值，并且为Future接口提供了一个实现类FutureTask，这个实现类既实现了Future接口，还实现了Runnable接口，因此可以作为Thread类的target。在Future接口里定义了几个公共方法来控制它关联的Callable任务。

1) boolean cancel(boolean mayInterruptIfRunning)：视图取消该Future里面关联的Callable任务

2) V get()：返回Callable里call（）方法的返回值，调用这个方法会导致程序阻塞，必须等到子线程结束后才会得到返回值

3) V get(long timeout,TimeUnit unit)：返回Callable里call（）方法的返回值，最多阻塞timeout时间，经过指定时间没有返回抛出TimeoutException

4) boolean isDone()：若Callable任务完成，返回True

5) boolean isCancelled()：如果在Callable任务正常完成前被取消，返回True

二、三种创建线程方法对比

实现Runnable和实现Callable接口的方式基本相同，不过是后者执行call()方法有返回值，后者线程执行体run()方法无返回值，因此可以把这两种方式归为一种这种方式与继承Thread类的方法之间的差别如下：：

1、适合多个相同的程序代码的线程去处理同一个资源

2、可以避免java中的单继承的限制

3、增加程序的健壮性，代码可以被多个线程共享，代码和数据独立

4、线程池只能放入实现Runable或callable类线程，不能直接放入继承Thread的类

联系：

1、Thread类是Runnable接口的子类。（publicclass Thread extends Object implements Runnable）

2、Runnable定义的子类中没有start()方法，只有Thread类中才有。而Thread类有一个构造方法：publicThread(Runnable targer)，此构造方法接受Runnable的子类实例，也就是说可以通过Thread类来启动Runnable实现的多线程。

 

三、线程状态转换

1、新建状态（New）：新创建了一个线程对象。

2、就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。

3、运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。

4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三种：

1）等待阻塞：运行的线程执行wait()方法，JVM会把该线程放入等待池中。(wait会释放持有的锁)

2）同步阻塞：运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放入锁池中。

3）其他阻塞：运行的线程执行sleep()或join()方法，或者发出了I/O请求时，JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。（注意,sleep是不会释放持有的锁）

5、死亡状态（Dead）：线程执行完了或者因异常退出了run()方法，该线程结束生命周期。

 

 

四、常用函数说明

1、Thread.sleep(longmillis)：使线程转到阻塞状态。millis参数设定睡眠的时间，以毫秒为单位。当睡眠结束后，就转为就绪（Runnable）状态。

2、Thread. join()：在子线程调用了join()方法后面的代码，只有等到子线程结束了才能执行。

3、Thread.yield()：让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

4、Obj.wait()：线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。

5、Obj.notify()：唤醒在此对象监视器上等待的单个线程。如果所有线程都在此对象上等待，则会选择唤醒其中一个线程。选择是任意性的，并在对实现做出决定时发生。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束类似的方法还有一个notifyAll()，唤醒在此对象监视器上等待的所有线程。

 

 

五、线程的调度

Java线程有优先级，优先级高的线程会获得较多的运行机会。Java线程的优先级用整数表示，取值范围是1~10，Thread类有以下三个静态常量：

static int MAX_PRIORITY

         线程可以具有的最高优先级，取值为10。

static int MIN_PRIORITY

         线程可以具有的最低优先级，取值为1。

static int NORM_PRIORITY

         分配给线程的默认优先级，取值为5。

Thread类的setPriority()和getPriority()方法分别用来设置和获取线程的优先级。

每个线程都有默认的优先级。主线程的默认优先级为Thread.NORM_PRIORITY。

线程的优先级有继承关系，比如A线程中创建了B线程，那么B将和A具有相同的优先级。

JVM提供了10个线程优先级，但与常见的操作系统都不能很好的映射。如果希望程序能移植到各个操作系统中，应该仅仅使用Thread类有以下三个静态常量作为优先级，这样能保证同样的优先级采用了同样的调度方式。

 

# Point

1、start()方法的调用后并不是立即执行多线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。

2、多线程程序是乱序执行。因此，只有乱序执行的代码才有必要设计为多线程。实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。

3、在java中，每次程序运行至少启动2个线程。一个是main线程，一个是垃圾收集线程。

4、在很多情况下，主线程生成并起动了子线程，如果子线程里要进行大量的耗时的运算，主线程往往将于子线程之前结束，但是如果主线程处理完其他的事务后，需要用到子线程的处理结果，也就是主线程需要等待子线程执行完成之后再结束，这个时候就要用join()方法来使得主线程在子线程之后结束。

5、 sleep()和yield()的区别：sleep()使当前线程进入停滞状态，所以执行sleep()的线程在指定的时间内肯定不会被执行；yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。 另外，sleep 方法允许较低优先级的线程获得运行机会，但 yield()  方法执行时，当前线程仍处在可运行状态，所以，不可能让出较低优先级的线程些时获得 CPU 占有权。

6、Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。

 

7、wait()和sleep()的区别

1）Thread类的方法：sleep(),yield()等 Object的方法：wait()和notify()等 
2）每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。 sleep方法没有释放锁，而wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。 
3）wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用 
4）sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常