多线程学习

1.什么是多线程？主要理解进程和线程。

　　进程：操作系统管理的基本运行单元，只是一个静态的概念，本身不能被执行。一个.exe文件，一个class文件就是一个进程，平时我们所说的一个进程开始执行了，其实是主线程被执行了。

　　多线程：就是一个进程里不同的执行路径。其实CPU一次只能执行同一个线程，由于不同线程之间切换的时间差很小，给人的感觉是同时进行而已。（个人理解为将CPU的利用率最大化）

 

2.如何创建线程？

　　实现runnable接口

　　继承Thread类（Thread类其实也是实现了runnable接口的子类）。

　　常见的创建线程的方式：

　　Thread thread = new Thread（

　　　　public void run（）{

　　　　　　//实现的业务逻辑

　　　　}

　　）.start();

 

3.线程的生命周期：

　　创建一个线程-》runnable状态等待被调用-》running状态-》dead（执行完或者抛出异常）

　　　　　　　　　　阻塞状态在runnable 和 running 之间

　　注意：如果直接调用线程的run方法即thread.run（）;那么是方法调用，不会呈多线程效果。

 

4.线程控制的基本方法

　　1.isAlive()判断线程是否终止

　　2.getPriority()/setPriority()获取/设置优先级

　　3.Thread.sleep()当前线程睡眠，可指定毫秒数

　　4.join()等待线程结束，在恢复此线程继续执行

　　5.yield() 让出CPU，进入runnable等待被调度

　　6.wait()当前线程进入对象的waitpool

　　7.notify()/notifyAll()唤醒一个或者唤醒对象所有的waitPoll

 

5.sleep()方法和wait()方法的区别 ？

　　1.sleep方法是Thread类的，而wait方法是Object类的

　　2.调用sleep方法不会释放对象锁，调用wait方法会释放对象锁

 

6.不要通过thread.stop（）的方式终止线程，此方法为强制关闭线程，有些资源不会被释放。

 

7.关键字synchronized

 

　　同步代码块synchronized(this){

　　　　......

　　}

 

　　synchronized method(){.......} 二者都是在执行的过程中都是锁定当前对象，是多线程学习的重点。

　　此处有个细节：同步方法时虽然锁住的是对象，但是没有加锁的方法依然可以异步访问。

8.线程死锁：程序中过多的同步会产生死锁。代码演示：

　　

/**
 * 代码演示线程死锁 一个简单的死锁类
 * 
 * 当DeadLock类的对象flag==1时（lock1），先锁定o1,睡眠500毫秒
 * 
 * 而lock1在睡眠的时候另一个flag==0的对象（lock2）线程启动，先锁定o2,睡眠500毫秒
 * 
 * lock1睡眠结束后需要锁定o2才能继续执行，而此时o2已被lock2锁定；
 * 
 * lock2睡眠结束后需要锁定o1才能继续执行，而此时o1已被lock1锁定；
 * 
 * lock1、lock2相互等待，都需要得到对方锁定的资源才能继续执行，从而死锁。
 */

public class TestDeadLock implements Runnable {
    public int flag = 1;
    static Object o1 = new Object(), o2 = new Object();

    @Override
    public void run() {
        System.out.println("flag=" + flag);
        if (flag == 1) {
            synchronized (o1) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized (o2) {
                    System.out.println("1");
                }
            }
        }
        if (flag == 0) {
            synchronized (o2) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                synchronized (o1) {
                    System.out.println("0");
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        TestDeadLock lock1 = new TestDeadLock();
        TestDeadLock lock2 = new TestDeadLock();

        lock1.flag = 1;
        lock2.flag = 0;

        new Thread(lock1).start();
        new Thread(lock2).start();
    }

}

9.与多线程相关的几个API

　　threadLocal :是每个线程独立拥有的对象，在当前线程中数据共享。set() 、get()方法====Map<Thread,变量>

　　timer: 定时器 请见timertest。new Timer().schedule(new TimerTask(){});创建一个定时器->计划什么时候执行->创建一个任务放到计划里

　　CountDownLatch:一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。await()->countDown()->当计数器为0时，程序才继续向下执行（很有用。）

package tcl.o2o.it.threadinjdk5;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Learn03CountdownLatchTest {

    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool(); // 创建一个线程池
        final CountDownLatch cdOrder = new CountDownLatch(1);// 指挥官的命令，设置为1，指挥官一下达命令，则cutDown,变为0，战士们执行任务
        final CountDownLatch cdAnswer = new CountDownLatch(3);// 因为有三个战士，所以初始值为3，每一个战士执行任务完毕则cutDown一次，当三个都执行完毕，变为0，则指挥官停止等待。
        for (int i = 0; i < 3; i++) {
            Runnable runnable = new Runnable() {
                public void run() {
                    try {
                        System.out.println("线程" + Thread.currentThread().getName() + "正准备接受命令");
                        cdOrder.await(); // 战士们都处于等待命令状态
                        System.out.println("线程" + Thread.currentThread().getName() + "已接受命令");
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("线程" + Thread.currentThread().getName() + "回应命令处理结果");
                        cdAnswer.countDown(); // 任务执行完毕，返回给指挥官，cdAnswer减1。
                    } catch (Exception e) {
                        e.printStackTrace();    
                    }
                }
            };
            service.execute(runnable);// 为线程池添加任务
        }
        try {
            Thread.sleep((long) (Math.random() * 10000));

            System.out.println("线程" + Thread.currentThread().getName() + "即将发布命令");
            cdOrder.countDown(); // 发送命令，cdOrder减1，处于等待的战士们停止等待转去执行任务。
            System.out.println("线程" + Thread.currentThread().getName() + "已发送命令，正在等待结果");
            cdAnswer.await(); // 命令发送后指挥官处于等待状态，一旦cdAnswer为0时停止等待继续往下执行
            System.out.println("线程" + Thread.currentThread().getName() + "已收到所有响应结果");
        } catch (Exception e) {
            e.printStackTrace();
        }
        service.shutdown(); // 任务结束，停止线程池的所有线程

    }
}

10.Lock 和 Condition

　　jdk1.5新特性锁：

　　　　ReentrantLock通用锁和ReentrantReadWriteLock读写锁。

　　　　ReentrantLock和synchronized方法类似 只不过是通过lock()和unlock()控制边界。

　　重点读写锁：除了read和read之外的任和锁都互斥

 

11.condition：Condition的功能类似于在传统的线程技术中的,Object.wait()和Object.notify()的功能。

 

12.线程池的使用

　　由于线程的生命周期中包括创建、就绪、运行、阻塞、销毁阶段，当我们待处理的任务数目较小时，我们可以自己创建几个线程来处理相应的任务，但当有大量的任务时，由于创建、销毁线程需要很大的开销，运用线程池这些问题就大大的缓解了。

　　Executors.newFixedThreadPool(3)// 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

　　Executors.newCachedThreadPool()//创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

　　Executors.newSingleThreadExecutor()//创建一个单线程化的线程池，它只会用唯一的工作线程来执行任、务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

　　corePoolSize、maximumPoolSize、largestPoolSize

 

13.jdk1.5新特性Callable和Future（Future用于接收实现了Callable接口的线程执行结果）

　　定义：callable接口类似于runnable，但是runnable不会有返回结果，callable有返回结果可以被future拿到

　　ExecutorService 的submit 和 excute的区别 ，前者有返回值future，execute没有返回值

 

　　CompletionService<Integer> completionService = new ExecutorCompletionService<Integer>(es); 批量提交任务，并获取返回结果

　　

package tcl.o2o.it.threadinjdk5;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Learn06ThreadFutureAndCallable01 {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        // TODO Auto-generated method stub
        ExecutorService es = Executors.newSingleThreadExecutor();
        Future<String> future = es.submit(new Callable<String>() {
            @Override
            public String call() throws Exception {
                // TODO Auto-generated method stub
                System.out.println("线程开始执行");
                Thread.sleep(1000);
                return "hello world";
            }
        });
        
        es.shutdown();
        System.out.println("等待返回结果");
        System.out.println(future.get());
    }

}

14.Semaphore-信号灯机制 当我们创建一个可扩展大小的线程池，并且需要在线程池内同时让有限数目的线程并发运行时，就需要用到Semaphore（信号灯机制）。acquire和release方法。

public class Learn08SemaphoreTest {
    public static void main(String[] args) {
        ExecutorService service = Executors.newCachedThreadPool();
        final Semaphore sp = new Semaphore(3);
        for (int i = 0; i < 5; i++) {
            Runnable runnable = new Runnable() {
                public void run() {
                    try {
                        sp.acquire();
                    } catch (InterruptedException e1) {
                        e1.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() + "进入，当前已有"
                            + (3 - sp.availablePermits()) + "个并发");
                    try {
                        Thread.sleep((long) (Math.random() * 10000));  
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("线程" + Thread.currentThread().getName() + "即将离开");
                    sp.release();
                    // 下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
                    System.out.println("线程" + Thread.currentThread().getName() + "已离开，当前已有"
                            + (3 - sp.availablePermits()) + "个并发");
                }
            };
            service.execute(runnable);
        }
    }
}

15.fork/join框架：ForkJoinPool由ForkJoinTask数组和ForkJoinWorkerThread数组组成，ForkJoinTask数组负责存放程序提交给ForkJoinPool的任务，而ForkJoinWorkerThread数组负责执行这些任务。

　　RecursiveAction：用于没有返回结果的任务。

　　RecursiveTask ：用于有返回结果的任务。

 

package tcl.o2o.it.threadinjdk5;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

public class Learn09ForkJoinTest extends RecursiveTask {
    private static int ThreadShold = 2;
    int start;
    int end;

    private Learn09ForkJoinTest(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum = 0;
        boolean flag = (end - start) <= ThreadShold;
        if (flag) {
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        } else {
            int middle = (start + end) / 2;
            Learn09ForkJoinTest leftTask = new Learn09ForkJoinTest(start, middle);
            Learn09ForkJoinTest rightTask = new Learn09ForkJoinTest(middle+1, end);

            leftTask.fork();//把任务放到该任务的顶部
            rightTask.fork();

            int leftResult = (Integer) leftTask.join();//执行完再往下走
            int rightResult = (Integer) rightTask.join();

            sum = leftResult + rightResult;
        }
        return sum;
    }
    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        long beginTime = System.currentTimeMillis();
        Learn09ForkJoinTest task = new Learn09ForkJoinTest(1, 100000);
        Future<Integer> result = forkJoinPool.submit(task);
        try {
            System.out.println(result.get());
            System.out.println( System.currentTimeMillis() - beginTime);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ExecutionException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        
    }
}