多线程

1、创建多线程

1、继承Thread类，并重写run()方法

    class MyThread extends Thread{
        @Override
        public void run() {
        }
    }

其中run()方法是线程的执行体，该线程想要完成的任务，都有在这里面定义

2、实现Runnable接口

        Runnable runnable=new Runnable() {
            @Override
            public void run() {
            }
        };
        //以runnable对象作为Thread对象的target
        Thread thread=new Thread(runnable);

Thread对象负责执行其target的run()方法，即最终Runnable 对象的run()方法要作为线程的执行体

public class Thread implements Runnable {
    public Thread(Runnable target) {
        init(null, target, "Thread-" + nextThreadNum(), 0);
    }

    @Override
    public void run() {
        if (target != null) {
            target.run();
        }
    }
 }

3、Callable、Future、FutureTask，可以实现在任务结束之后，返回结果

Callable提供了call()方法作为线程的执行体，call()方法有返回值，可以抛出异常。

public interface Callable<V> {
    V call() throws Exception;
}

但是Callable不是Runnable接口的子接口，所以不能直接作为Thread对象的target。

public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    //获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

public interface RunnableFuture<V> extends Runnable, Future<V> {
    void run();
}

可以看出FutureTask最终继承了Runnable接口和Future接口。所以它即可以直接作为Thread对象的target使用，又可以作为Future得到Callable的返回值。如下可以看出，FutureTask实现了Runnable接口的run() 方法，并在run() 里调用了Callable的call()方法：所以，call()方法将作为线程的执行体。

public class FutureTask<V> implements RunnableFuture<V> {
    ...
    public FutureTask(Callable<V> callable) {
        ...
        this.callable = callable;
    }

    public void run() {
            ...
            Callable<V> c = callable;
            V result;
            result = c.call();
            set(result);
    }
}

** 三种方式的优缺点？**
1、线程类实现Callable、Runnable接口，还可以继承其他类；如果已经继承Thread类，就不能再继承其他类了
2、使用Callable、Runnable接口，多个线程可以共享同一个target对象，非常适合多个线程，处理同一份资源的情况
3、使用Callable，有返回值

2、线程的生命周期

在线程的生命周期中，它要经过新建（ｎｅｗ）、就绪（ｒｕｎｎａｂｌｅ）、运行（ｒｕｎｎｉｎｇ）、阻塞（ｂｌｏｃｋ）、死亡（ｄｅａｄ）五种状态。

新建的线程调用start()方法，进入就绪状态，就绪状态下的线程获得了CPU，进入运行状态，此时开始执行run()方法。在发生如下情况时，线程将进入阻塞状态：

线程调用sleep()方法，主动放弃所占用的处理器资源
线程调用了一个阻塞式IO方法，在该方法返回之前，该线程将被阻塞
线程试图获得一个同步监听器，但该同步监听器正在被其他线程持有
．．．

当前线程被阻塞后，其他线程就可以获得执行的机会；被阻塞的线程会下合适的时候，进入就绪状态。

线程状态

３、控制线程

１、join线程

当在一个线程调用其他线程的join()后，调用线程将被阻塞，直到其他线程（join线程）被执行完为止

        Thread thread=new Thread("");
        thread.join();

２、线程睡眠sleep

让当前线程暂停一段时间，并进入阻塞状态，可以调用Thread类的静态sleep()方法：在其sleep时间段内，该线程不会获得执行的机会

        Thread.sleep(3000);

３、线程让步，yield

让当前线程暂停，但不会阻塞该线程，只是将该线程进入就绪状态：让系统的线程调度器重新调度一次。
只有优先级和当前线程相同，或者比当前线程高，处于就绪状态的线程才能获得执行机会。

        Thread.yield();

sleep()方法拥有更好的移植性，通常不建议使用yield()方法控制并发线程的执行。

４、线程同步synchronized

Java关键字，是用来进行同步的。可以修饰代码块，或者方法。

／／　多线程并发修改一个对象的时候，可能会引起问题。

１、同步代码块

线程在开始执行同步代码块之前，必须先获得对同步监视器（ｏｂｊ）的锁定。

        synchronized (obj){
            //同步代码块
        }

同步监视器可以是一个对象，也可以是一个类T，如下

        synchronized (T.class){
            //同步代码块
        }

任何时刻，只能有一个线程可以获得对同步监视器的锁定，当同步代码块执行完毕后，该线程会释放对同步监视器的锁定；

注意：
1、如果同步监视器是一个对象，当多个线程访问该对象的同步代码块时，有些线程会被阻塞，但是如果不同线程访问的是不同对象的同步代码，不会阻塞；
2、如果同步监视器是一个类，代表锁定的是一个类，当多个线程访问该类不同对象的的同步代码块时，有些线程依然会被阻塞。

２、同步方法

使用synchronized 来修饰某个方法，它的同步监视器默认是当前对象

   public synchronized void ｘｘ(){}

注意： synchronized关键字也可以修饰静态方法，此时它的同步监视器是类，当多个线程访问该类不同对象的的同步代码块时，有些线程依然会被阻塞。

３、释放同步监视器

任何线程在进入同步代码块／同步方法之前。必须先获得对同步监视器的锁定，那么什么时候会释放对同步监视器的锁定呢？

执行结束
遇到了break、return
遇到了Error、Exception
当前线程在执行同步代码块／同步方法时，执行了同步监视器对象的ｗａｉｔ（）方法，则当前线程暂停，并释放同步监视器

注意：当前线程在执行同步代码块／同步方法时，调用了Thread.sleep()、Thread.yield()方法，当前线程不会释放同步监视器

同步是以降低程序的运行效率为代价的，因此应该尽量减少同步的内容。

不要对线程安全类的所有方法进行同步，只对那些会改变竞争（共享）资源的方法进行同步
通常没有必要同步整个方法，使用synchronized代码块同步关键代码即可。

多线程