(一)Java并发基础介绍

什么是线程

现代操作系统运行一个应用程序的时候会创建一个进程，进程中包含多个线程，线程是现在操作系统的最小调度单元，也叫轻量级进程。这些咸亨都具有各自的计数器，堆和局部变量，并且能访问共享的内存变量。

为什么要使用多线程

更多的处理器核心
多线程会将线程分配到多个处理器CPU，程序云溪行时间显著减少。
更快的响应时间
更好的变成模型
Java提供了很好的并且一致的编程模型，我们使用简单。

线程优先级

Java线程通过一个成员变量priority来控制优先级，范围从1~10,可以通过setPriority(int)来设置，默认优先级为5。优先级高的线程分配的时间片多于优先级低的线程。

Thread thread = new Thread(job,"thread-1");
thread.setPriority(5);
thread.start();

注意：优先级只确定时间片的多少，线程的调度是CPU进行的，所以优先级并不能确定线程执行的顺序。

线程的状态

线程状态

如图：

NEW:初始状态，线程被构建，但没有调用start方法。
RUNNABLE：运行状态，这里包含两个小状态就绪和运行，Java统称为运行状态。
BLOCKED:阻塞状态，线程阻塞与锁
WAITING：等待状态，线程进入等待，表示当前线程需要等待其他线程做出一些特定动作(通知或中断)
TIME_WAITING: 超时等待，不同于WAITING，线程会在指定时间自己返回
TERMINATED: Dead,线程执行完毕.

Daemon(守护线程

Daemon是一种支持性线程，它主要用于后台调度和支持形工作。Daemon使用setDaemon(true)来设置

thread.setDaemon(true);

线程创建的三种方式

继承Thread类。
实现Runnable接口。
实现Callable接口。

1.继承Thread类

通过实现父类run方法，来实现多线程，多线程间无法共享线程变量。

public class ThreadOne extends Thread {
    @Override
    public void run() {
        super.run();
        System.out.println(" new Thread");
    }

     public static void main(String[] args) {
       ThreadOne one = new ThreadOne();
        one.start(); // 线程调用start方法就是线程开始执行，就会寻星run方法。
    }
}

2.实现Runnable接口

实现Runnable接口，实现run方法，并用Thread类调用开始。适合用于多线程处理同一成员变量

public class ThreadOne implements Runnable {
    int i = 0;
    public void run() {
        System.out.println(" new Thread " + (i++));
    }

    public static void main(String[] args) {
        ThreadOne one = new ThreadOne();
        new Thread(one, "a").start();
        new Thread(one, "aa").start();
    }
}

注意：从上述代码中可以看出，实现Runnable的运行需要与Thread类结合使用，这里可以介绍，Thread类是对线程的操作，可以理解为它不是线程，它自己的start、wait等方法都是对线程的操作，通过继承Thread类来实现多线程是将线程的运行逻辑(run方法)和线程的操作放一起了，这就造成多线程见无法方法变量。通过实现Runnable接口，在用thread类包裹Runnable接口，这就是将线程的运行逻辑与线程的操作分开，所以在上述例子中，两个线程操作一个线程实现，这就造成两个线程操作都让线程实现的run方法运行，也就是run方法执行两次，如果多个线程操作的Thread同时操作一个Runnable，就会造成上述例子中变量i的错误访问，也就是线程冲突。

3.实现Callable接口

这个和Runnable接口类似，但是Runnable接口没有返回值，而Callable接口是有返回值的，也可以说线程有返回值。

public class ThreadUser {
    private int id;
    private String name;
}

public class ThreadCallable implements Callable {

    public ThreadUser call() throws Exception {
        ThreadUser user = new ThreadUser();
        user.setId(1);
        user.setName("song");
        Thread.sleep(5000);
        System.out.println(Thread.currentThread().getName()+ " Thread");
        return user;
    }


    public static void main(String[] args) {
        ThreadCallable callable = new ThreadCallable();

        FutureTask task = new FutureTask(callable);
        //这里注意，两个线程同时传入一个FutureTask对象，FutureTask对象只会执行一次
        new Thread(task, "a").start();
        new Thread(task, "aa").start();

        //需要执行两次就需要重新建立FutureTask对象。
        FutureTask task1 = new FutureTask(callable);
        new Thread(task1, "bb").start();

        try {
            System.out.println("FutureTask call back: " + task.get().toString());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
 
    }
}

上述例子中可以看出，这中实现方法需要三个类来实现，实现Callable的类， FutureTask类，Thread类。

实现Callable接口，实现call方法，并返回需要的参数。
使用FutureTask类对实现Callable的类进行封装。
用Thread类对FutureTask类进行包裹，并执行，
4.使用FuturnTask类对象的get方法获取线程中Callable的返回值。
注意1：如上例子所示FutureTask的特点是一个实例，Callable中的call方法执行一次，多个Thread也是执行一个，这个与Runnable不同，
注意2： FutureTask的get方法是阻塞方法，也就是说，只有Callable方法执行完了返回，get方法才会执行。