Java多线程

基本概念

并行：多个CPU实例或者多台机器同时执行一段处理逻辑，是真正的同时。

并发：通过cpu调度算法，让用户看上去同时执行，实际上从cpu操作层面，不是真正的同时。

线程安全：在并发的情况下，该代码经过多线程使用，线程的调度顺序不影响任何结果。这个时候使用多线程，我们只需要关注系统的内存，cpu是不是够用即可，反过来，线程不安全就意味着线程的调度顺序会影响最终结果。

同步：通过人为的控制和调度，保证共享资源的多线程访问成为线程安全，来保证结果的准确。

线程状态

java线程的五种基本状态：

新建状态（New）：当线程对象被创建后，即进入了新建状态。

就绪状态（Runnable）：当调用线程对象的start()方法，线程即进入了就绪状态，处于就绪状态的线程，只是说明此线程做好了准备，随时等待CPU调度执行，并不是说执行了start()此线程就立即会运行。

运行状态（Running）：当CPU开始调度处于就绪状态的线程时，此线程才得以真正执行，即进入到运行状态。就绪状态是进入到运行状态的唯一入口。

阻塞状态（Blocked）：处于运行中的线程由于某种原因，暂时放弃对CPU的使用权，停止执行，此时进入阻塞状态，直到进入就绪状态，才有机会再次被CPU调用以进入运行状态。根据阻塞的原因不同，阻塞桩体可以分为三种：

1、等待阻塞：运行中状态中的线程执行wait()方法，使本线程进入到等待阻塞状态。

2、同步阻塞：线程在获取synchronized同步锁失败（因为所被其他线程所占用），它会进入同步阻塞状态。

3、其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程就会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态。

死亡状态（Dead）：线程只想完了或者因一场退出了run()方法，该线程结束生命周期。

多线程的实现

在Java中，实现多线程的方法有三种，一种是继承Thread类，第二种是实现Runnable接口，第三种是实现Callable接口。

1、继承Thread类

Thread类是在java.lang包中定义的，一个类只要继承了Thread类，同时重写了父类中的run()方法，就可以实现多线程操作了，但是一个类只能继承一个父类，这是此方法的局限。

线程类：

public class MyThread extends Thread {
	
	private int i = 0;
	
	@Override
	public void run(){
		for(i =0;i < 20;i++){
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}

}

测试类：

public class ThreadTest {
	
	public static void main(String[] args) {
		// 创建一个新的线程myThread1 此线程处于新建状态
		Thread myThread1 = new MyThread();
		// 创建一个新的线程myThread2 此线程处于新建状态
		Thread myThread2 = new MyThread();
		// 调用 start()方法是的线程进入就绪状态
		myThread1.start();
		myThread2.start();
	}

}

运行结果，因为线程都是抢占CPU资源的，所以输出结果是无序的。

2、实现Runnable接口

实现类：

public class MyRunnable implements Runnable {
	private int i = 0;

	@Override
	public void run() {
		for(i =0;i < 20;i++){
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
	}

}

测试类：

public class ThreadTest {
	
	public static void main(String[] args) {
		// 将MyRunnable作为Thread的target创建新的线程
		Thread myThread1 = new Thread(new MyRunnable());
		Thread myThread2 = new Thread(new MyRunnable());
		// 调用 start()方法是的线程进入就绪状态
		myThread1.start();
		myThread2.start();
	}

}

运行结果：

如果将测试类代码改成这样：

public class ThreadTest {
	
	public static void main(String[] args) {
		// 将MyRunnable作为Thread的target创建新的线程
		Runnable r = new MyRunnable();
		Thread myThread1 = new Thread(r);
		Thread myThread2 = new Thread(r);
		// 调用 start()方法是的线程进入就绪状态
		myThread1.start();
		myThread2.start();
	}

}

运行结果：

因为此时只实例化了一个Runable。两个线程对同一个资源进行操作。

3、实现Callable接口

使用Callable和Future接口创建线程。具体是创建Callable接口的实现类，并实现clall()方法。并使用FutureTask类来包装Callable实现类的对象，且以此FutureTask对象作为Thread对象的target来创建线程。

实现类：

import java.util.concurrent.Callable;

public class MyCallable implements Callable<Integer> {

	private int i = 0;
	
	@Override
	public Integer call() throws Exception {
		// TODO Auto-generated method stub
		for(i = 0;i < 20;i++){
			System.out.println(Thread.currentThread().getName() + ":" + i);
		}
		return 0;
	}

}

测试类：

import java.util.concurrent.FutureTask;


public class ThreadTest {
	
	public static void main(String[] args) {
		// 将MyRunnable作为Thread的target创建新的线程
		Thread myThread1 = new Thread(new FutureTask(new MyCallable()));
		Thread myThread2 = new Thread(new FutureTask(new MyCallable()));
		// 调用 start()方法是的线程进入就绪状态
		myThread1.start();
		myThread2.start();
	}

}

运行结果：

FutureTask部分源码，可见其实现了RunnableFuture接口

public interface FutureTask<V> implements RunnableFuture<V> {
	//省略了很多代码，有兴趣的读者可以使用idea或者其他带反编译的ide进行查看
	public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        this.callable = callable;
        this.state = NEW;       // ensure visibility of callable
    }
	
}

RunnableFuture源码，在接口中是可以多继承的，所以RunnableFuture是同时具有Runnable和Future的特性的。

public interface RunnableFuture<V> extends Runnable, Future<V> {
    /**
     * Sets this Future to the result of its computation
     * unless it has been cancelled.
     */
    void run();
}