Java多线程

引文

在复习多线程之前，我们得先明白一下几个概念：
①进程与线程的区别：
http://blog.csdn.net/mingming_shiwo/article/details/76037935

②并行与并发的区别：
并行：两个或多个事件或活动在同一时刻发生；多个程序在同一时刻在多个CPU上同时执行；
并发：一个CPU或者多个CPU在若干程序之间多路复用；并发性是对有限的物理资源强制行使多用户共享以提高效率。
打个比方：一个母亲给两个孩子喂饭，你一口他一口，表面上看是两个孩子一块吃饭，这就是并发；而父亲和母亲同时一人给一个孩子喂饭，这就是并行。

③同步与异步：
同步：指发送一个请求，需要等待返回，然后才能够发送下一个请求，有个等待的过程；
异步：指发送一个请求，不需要等待，随时可以发送下一个请求。
打个比方：下班了，同事叫你去吃饭，你没听见，然后同时就一直叫你，直到你回答说是去或者不去，这就叫同步；而同事叫你吃饭，在叫完你之后就直接自己去吃了，并不理会你去不去，这就叫异步。

线程的状态及状态转移图

NEW：刚创建还没启动
RUNNABLE：就绪状态，随时可以执行
RUNNNING：正在执行
BLOCKED：阻塞状态，等待持有锁
WAITING：处理等待状态
TERMINATED：终止状态
TIMEWAITING：睡眠状态

多线程的实现的三种方式

一、继承Thread类，并重该类的run()方法：

class MyThread extends Thread{

    @Override
    public void run(){
        System.out.println(Thread.currentThread().getName());
    }
}

public class ThreadDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("Main线程开始启动：");
        //创建一个新的线程myThread1，此线程进入新建状态
        Thread myThread1 = new MyThread();
        //创建一个新的线程myThread2，此线程进入新建状态
        Thread myThread2 = new MyThread();

        //调用start()方法使线程进入就绪状态
        myThread1.start();
        myThread2.start();

        try {
            //join()是为了等待主线程终止
            myThread1.join();
            myThread2.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("Main线程结束");
    }
}

执行结果：

Main线程开始启动：
Thread-0
Thread-1
Main线程结束

二、实现Runnable接口，并重写该接口的run()方法：

class MyThread implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println(Thread.currentThread().getName());
    }
}

public class ThreadDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("Main线程开始启动：");
        //创建一个Runnable接口的实现类的对象
        Runnable myThread = new MyThread();
        //将myThread作为Thread target来创建新的线程myThread1，此线程进入新建状态
        Thread myThread1 = new Thread(myThread);
        //将myThread作为Thread target来创建新的线程myThread2，此线程进入新建状态
        Thread myThread2 = new Thread(myThread);

        //调用start()方法使线程进入就绪状态
        myThread1.start();
        myThread2.start();

        //join()是为了等待主线程终止
        try {
            myThread1.join();
            myThread2.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("Main线程结束");
    }
}

执行结果：

Main线程开始启动：
Thread-0
Thread-1
Main线程结束

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

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

class MyThread implements Callable<Integer>{

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

}

public class ThreadDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        System.out.println("Main线程开始启动：");
        //创建Callable接口的实现类MyThread的对象
        Callable<Integer> myCallable = new MyThread();
        //使用FutureTask类来包装myCallable对象
        FutureTask<Integer> ft = new FutureTask<>(myCallable);

        //FutureTask对象作为Thread对象的target创建新的线程MyThread1
        Thread myThread1 = new Thread(ft);  

        myThread1.start();

        try {
            System.out.println("count = " + ft.get());
        } catch (InterruptedException | ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        System.out.println("Main线程结束");
    }

执行结果：

Main线程开始启动：
Thread-0 0
Thread-0 1
Thread-0 2
Thread-0 3
Thread-0 4
count = 10
Main线程结束