线程与进程

1.进程是处于运行过程中的程序，并且具有一定的独立功能，其是系统进行资源分配和调度的一个独立单位，它可以拥有自己独立的资源，每一个都拥有自己的私有的地址空间。进程有独立性、动态性、并发性特征。
2.线程是进程的组成部分，线程可以拥有自己的堆栈、自己的程序计数器和自己的局部变量，但不用有系统资源，它与父进程的其他线程共享该进程所拥有的全部资源。

线程的创建和启动

继承Thread类创建线程类

1.定义Thread的子类，并重写该类的run()方法，run()代表该线程的任务实体
2.创建子类实例
3.调用子类实例的start()方法来启动该线程。

public class ThreadTest1 extends Thread{
    private int i;
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"-"+i);
        }
    }
    public static void main(String[] args){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-"+i);
            if (i==20){
                    try {
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                new ThreadTest1().start();
                new ThreadTest1().start();
            }
        }
    }
}

注：Thread.currentThread()是Thread的静态方法，返回当前执行的线程对象；getName()是实例，获取调用该方法的线程对象的名称。

实现Runnable接口创建线程类

1.定义Runnable接口的实现类，重写该接口的run()方法，该方法也是线程的执行体。
2.创建Runnable实现类的实例，并以此实例为tagret创建一个Thread对象，该Thread才是真正的线程对象。
3.调用线程对象的start()方法启动该线程。

public class ThreadTest1 implements Runnable{
    private int i;
    @Override
    public void run() {
        for (; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-"+i);
        }
    }
    public static void main(String[] args){
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-"+i);
            if (i==20){
                ThreadTest1 rn = new ThreadTest1();
                Thread st1 = new Thread(rn,"新线程1");
                Thread st2 = new Thread(rn,"新线程2");
                st1.start();
                st2.start();
            }
        }

    }
}

注：采用Runnable接口方式创建的多个线程可以共享线程类的实例变量，这是因为程序所创建的Runnable对象只是线程的target，而多个线程可以共享一个target，所以多个线程可以共享同一个线程类(target)。

使用Callable和Future创建线程

1.创建Callable接口的实现类，并实现call()方法，再创建Callable实现类的实例。
2.使用FutureTask类来包装Callable对象，该FutureTask对象封装该Callable对象的call()方法的返回值。
3.使用FutrueTask对象作为Thread对象的taget创建并启动新线程。
4.调用FutureTask对象的get()方法来获得子线程执行结束后的返回值。

public class CallableTest{
    public static void main(String[] args){
        Callable<Integer> callable = new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
                int i = 0;
                for (; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName()+"-"+i);
                }
                return i;
            }
        };
        FutureTask<Integer> futureTask = new FutureTask<Integer>(callable);
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-"+i);
            if (i==20){
                new Thread(futureTask).start();
                new Thread(futureTask).start();
            }
        }
    }
}

注：
1.call()方法可以有返回值，且能抛出异常。
2.FutureTask实现了Future接口，并实现了Runnable接口。
3.FutureTask的几个方法能够控制它关联的Callable任务。

线程的生命周期

在线程的生命周期中，它要经过新建、就绪、运行、阻塞和死亡5种状态。
1.新建：当程序使用new关键字创建了一个线程之后，该线程就处于新建状态，此时它和其他Java对象一样。
2.就绪：程序调用线程的start()方法之后。
注：启动线程要用start()，而不是run()，直接调用run()的话程序只是把线程当成一个普通对象，而不是线程对象，对应的run()方法也只是一个普通方法，而不是线程执行体。
3.运行：如果就绪的线程获得了CPU，run()方法开始执行。
4.阻塞：
(1)线程调用sleep()方法主动放弃占用的处理器资源
(2)线程调用了一个阻塞式IO方法，在该方法返回之前线程阻塞。
(3)线程视图获得一个同步监视器，但该同步监视器正被其他线程所持有。
(4)线程在等待某个通知。
(5)程序调用了线程的suspend()方法将该线程挂起，容易导致死锁。
5.死亡:
(1)run()或call()执行完成，线程正常结束。
(2)线程抛出一个未捕获的Exception或Error。
(3)调用stop()方法来结束线程，容易导致死锁。

线程生命周期.jpg

控制线程

join线程

当某个程序执行流中调用其他线程的join()方法时，调用线程将被阻塞，直到被join()方法加入的join线程执行完为止。

public class ThreadTest extends Thread{
    private int i;
    public ThreadTest(String name){
        super(name);
    }
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+"-"+i);
        }
    }
    public static void main(String[] args){
        new ThreadTest("普通线程").start();
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName()+"-"+i);
            if (i==20){
                ThreadTest th = new ThreadTest("join线程");
                th.start();
                try {
                    th.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

可以看到由于在主线程中调用了"join线程"的join()方法，所以主线程从i==20开始阻塞，必须等待"join线程"执行完成之后才能继续执行，而"普通线程"则不受影响，与"join线程"并发执行。还有join(long mills)比较常用，表示等待被join的线程的时间最长为mills毫秒，若超过则不再等待。

后台线程

在后台运行，为其他的线程提供服务的线程被称为“后台线程”，其基本特征是如果所有前台线程都死亡，后台线程会自动死亡。
调用Thread对象的setDaemon(true)方法可将指定线程设置成后台线程，还可以调用isDaemon()用于判断指定线程是否为后台线程。前台线程创建的子线程默认是前台线程，后台线程创建的子线程默认是后台线程。

线程睡眠：sleep

调用Thread.sleep(long mills)方法可以使当前线程暂停mills毫秒，并进入阻塞状态。

线程让步：yield

与sleep相似，yield方法也是静态方法，也可以让当前线程暂停，但不会阻塞该线程，二十将线程转入就绪状态。即就算当前线程调用了yield方法，它也有可能立即获得CPU而得到执行，具体取决于系统调度策略和线程优先级。

调用线程对象的setPriority(int)可以设置线程的优先级，常用的有Priority.MIN_PRIORITY、Priority.MAX_PRIORITY、Priority.NORM_PRIORITY三个值(分别对应Java线程优先级数值的0、10、5)。

线程同步

线程同步是为了解决线程安全问题的，典型的线程安全问题如多个线程同时对银行同一个账户进行取钱操作。
线程同步一共有三种基本方式：同步代码块、同步方法、同步锁。

同步代码块

synchronized(obj){
  ...
  //此处为同步代码块
}

上述代码synchronized括号中的obj是同步监视器，意思是线程开始执行之前必须先获得同步监视器的锁定，如账户可以写成：

synchronized(account){
  ...
  //此处为同步代码块
}

同步方法

同步方法的同步监视器是this，即调用该方法的对象，如Account类的取钱方法draw()：

public synchronized void draw(double drawAmount){
  ...
  //取钱代码
}

注：synchronized关键字可以修饰方法、代码快，但不能修饰构造器、成员变量等。

同步锁

通过显式定义同步锁对象来实现同步的机制，同步锁由Lock对象充当。在实现线程安全的控制中，比较常用的是ReentrantLock，，其常见的使用形式为：

class X｛
  //定义锁对象
  private final ReentrantLock lock = new ReentrantLock ();
  //...
 
 //定义需要保证线程安全的方法
  public void m(){
    lock.lock();
    try{
      //需要保证线程安全的代码
    }
    finally{
      lock.unlock();
    }
  }
｝

死锁

当两个线程相互等待对象释放同步监视器时就会发生死锁，该现象不会发生异常，也不会给提示，只是所有线程处于阻塞状态。

线程通信

传统的线程通信

传统的线程通信主要是通过Object类提供的wait()、notify()、notifyAll()这三个方法来实现，这三个方法必须由同步监视器对象来调用：同步方法中直接调用；同步代码块中同步监视器是synchronized括号里的对象，必须由该对象调用
wait():导致当前线程等待，知道其他线程调用该同步监视器的notify()方法或notifyAll()方法来唤醒该线程。
notify():随机唤醒在此同步监视器上等待的单个线程。
notifyAll():唤醒在此同步监视器上等待的所有线程。

使用Condition控制线程通信

主要针对使用Lock对象实现线程同步的代码。Condition被绑定在Lock对象上，可以通过Lock对象的newCondition()方法获取Condition对象。该对象也有三个方法对应上述方法：
await():导致当前线程等待，直到其他线程调用该Condition的signal()方法或signalAll()方法来唤醒该线程。
signal():随机唤醒在此Lock对象上等待的单个线程。
signalAll():唤醒在此Lock对象上等待的所有线程。

使用阻塞队列(BlockingQueue)控制线程通信

BlockingQueue是一个接口，其也是Queue的接口，但其并不是用来当作容器。其有个特征：当生产者线程试图向BlockingQueue中放入元素时，如果该队列已满，则该线程被阻塞；当消费者线程试图从BlockingQueue中取出元素时，如果该队列已空，则该线程阻塞。由此控制线程的通信。对应的控制线程的方法是：
put()：执行时如果队列已满则阻塞调用线程。
take()：执行时如果队列为空则阻塞调用线程。

线程相关类

ThreadLocal类

ThreadLocal就是为每一个使用该变量的线程都提供一个变量值的副本而存在的，使每一个线程都可以独立地改变自己的副本，而不会和其他线程的副本冲突。其提供三个方法：
T get():返回当前线程局部变量副本的值。
void remove:删除当前线程的局部变量副本的值。
void set(T value):设置当前线程布局变量副本的值。
其使用方法与类的普通变量相似：

public class Account {
    private ThreadLocal<String> name = new ThreadLocal<>();
    public Account(String str){
        name.set(str);
    }

    public String getName() {
        return name.get();
    }

    public void setName(String name) {
        this.name.set(name);
    }
}

同步和ThreadLocal用途的区别

1.同步机制是为了同步多个线程对相同资源的并发访问，是多个线程之间进行通信的有效方法
2.ThreadLocal是为了隔离多个线程的数据共享，从根本上避免多个线程之间对共享资源的竞争，也就不需要对多个线程进行同步了。

包装线程不安全的集合

程序中有多个线程访问集合类，可以使用Collections提供的类方法把这些集合包装成线程安全的集合。
1.<T>Collection<T> synchronizedCollection(Collection<T> c)
2.static <T>List<T> synchronizedList(List<T> list)
3.static <K,V>(Sorted)Map<K,V> synchronized((Sorted)Map<K,V> map)
2.static <T>(Sorted)Set<T> synchronizedSet((Sorted)Set<T> set)

HashMap m = Collections.synchronizedMap(new HashMap());

线程安全的集合类

Java5开始，java.util.concurrent包下提供了大量支持高效并发访问的集合接口和实现类。
其主要分为两类：
1.以Concurrent开的集合类，如ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentSkipListSet、ConcurrentLinkedQueue和ConcurrentLinkedDeque等。
2.以CopyOnWrite开头的集合类，如CopyOnWriteArrayList、CopyOnWriteArraySet等。

Concurrent开头的集合类代表了支持并发访问的集合，它们可以支持多个线程并发写入访问，这些写入线程的所有操作都是线程安全的，但读取操作不必锁定。
当线程对CopyOnWriteArrayList集合执行读取操作时，线程将会直接读取集合本身，无须枷锁和阻塞，当线程对ConpyOnWriteArrayList集合执行写入操作时，该集合会在底层赋值一份新的数组，对新的数组执行写入操作。所以CopyOnWriteArrayList适合用再读取操作远大于写入操作的场景，如缓存。