线程学习补充

解决线程安全问题：

1.synchronized隐式锁
    同步代码块
    同步方法
2.JDK1.5后
    同步锁Lock   lock()方方法上锁  必须要，unlock 方法解锁
    private Lock lock=new ReentranLock();
    public void run(){
        while(true){
            lock.lock();//上锁
            try{
                if(tick>0){
                    try{
                        Thread.sleep(200);
                    }catch(InterruptedException e){
                    }
                    sysytem.out.println(Thread.currentThread().getName());
                }                
            }finally{
                lock.unlock();//释放锁
            }
        }    
    }
    
1，线程交替打印 lock示例：condition控制线程通信
public class TestABCAlternate{
    public static void main(String[] args){
        AlternateDemo ad=new AlternateDemo();
        new Thread(new Runnable(){
            public void run(){
                for(int i=1;i<=20;i++){
                    ad.loopA(i);
                }
            }
        },"A").start();
        new Thread(new Runnable(){
            public void run(){
                for(int i=1;i<=20;i++){
                    ad.loopB(i);
                }
            }
        },"B").start();
        new Thread(new Runnable(){
            public void run(){
                for(int i=1;i<=20;i++){
                    ad.loopC(i);
                }
            }
        },"C").start();
    }
}
class AlternateDemo{
    private int number=1;//当前正在执行线程的标记
    private Lock lock=new ReentranLock();
    private Condition condition1=lock.newCondition();
    private Condition condition2=lock.newCondition();
    private Condition condition3=lock.newCondition();    
    public void loopA(){
        lock.lock();
        try{
            if(number!=1){
                condition1.await();//等待，，说明不属于1 打印
            }
            for(int i=1;i<=1;i++){
                system.out.println(Thread.currentThread().getName()+ i +totalLoop);
            }
            number=2;
            condition2.signal();//唤醒2        
        }catch(Exception e){
        
        }finally{
            lock.unlock();
        }    
    }
    public void loopB(){
        lock.lock();
        try{
            if(number!=1){
                condition1.await();//等待，，说明不属于1 打印
            }
            for(int i=1;i<=1;i++){
                system.out.println(Thread.currentThread().getName()+ i +totalLoop);
            }
            number=3;
            condition3.signal();//唤醒2       
        }catch(Exception e){    
        }finally{
            lock.unlock();
        }    
    }
    public void loopC(){
        lock.lock();
        try{
            if(number!=1){
                condition1.await();//等待，，说明不属于1 打印
            }
            for(int i=1;i<=1;i++){
                system.out.println(Thread.currentThread().getName()+ i +totalLoop);
            }
            number=1;
            condition1.signal();//唤醒2        
        }catch(Exception e){        
        }finally{
            lock.unlock();
        }    
    }    
}
    
读写锁：ReadWriteLock  写写/读写  需要互斥
    读可以允许多个线程操作
    写只能有一个线程操作
class ReadWriteLockDemo{
    private int number=0;
    private ReadWriteLock lock=new ReentranReadWriteLock();//创建读写锁
    
    //读
    public void get(){
        lock.readLock.lock();//上锁
        try{
            system.out.println(number);
        }finally{
            lock.readLock.unlock();//释放锁
        }
    }    
    //写
    public void set(int number){
        lock.writeLock.lock();
        try{
            system.out.println(number);
        }finally{
            lock.writeLock.unlock();//释放锁
        }
    }    
}    
    
1.两个普通同步方法，两个线程，标准打印？one  two
2.新增Thread.sleep()给getOne(),打印？ one  two 
3.新增普通同步方法getThread(),打印？ one two
4.两个普通同步方法，两个number对象，打印？two  one 
5.修改getOne()为静态同步方法，一个number对象？two one
6.修改两个方法均为静态同步方法，一个number对象？one  two
7.一个静态同步方法，一个非静态同步方法，两个number对象？two  one 
8.两个静态同步方法，两个number对象？one  two

线程八锁的关键：
1.非静态方法的锁默认为this，静态方法的锁为对应的class实例
2.某一个时刻内，只能有一个线程持有锁，无论几个方法。
    
    
一、线程池：
    提供了一个线程队列，队列中保存着所有等待状态的线程，
    避免了创建与销毁开销，提高了响应速度。
二、线程池的体系结构
    java.util.concurrent.Executor:负责线程的使用与调度的根接口
        ExecutorService子接口：线程池的主要接口
            ThreadPoolExecutor 线程池的实现类
            ScheduledExecutorService 子接口：负责线程的调度
                ScheduledThreadPollExecutor:继承ThreadPoolExecutor，实现ScheduledExecutorService
三、工具类 Executors
        ExecutorService  newFixedThreadPool();创建固定大小的线程池
        ExecutorService  newCachedThreadPool();缓存线程池，线程池的数量不固定，可以根据需求自动的更改数量
        ExecutorService  newSingleThreadExecutor();创建单个线程池，线程池中只有一个线程
     
     ScheduledExecutorService  newScheduledThreadPool();创建固定大小的线程，可以延迟或定时的执行任务。
public class TestThreadPool{
    public static void main(String[] args){
        //1.创建线程池  固定大小线程池
        ExecutorService pool=Executors.newFixedThreadPool(5);
        ThreadPoolDemo ted=new ThreadPoolDemo();
        //2.为线程池中的线程分配任务
        pool.submit(ted);
        //3.关闭线程池
        pool.shutdown();
        
    }

    class ThreadPoolDemo implements Runnable{
        private int i=0;
        public void run(){
            while(i<100){
                i++;
                system.out.println("");
            }
        }    
    }
    
    Callable位于java.util.concurrent包下，它也是一个接口，在它里面也只声明了一个方法，只不过这个方法叫做call()
    Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。
    必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果
    
    
    创建执行线程的方式三：
        1.实现Callable接口，相较于实现Runnable接口的方式，方式可以有返回值，并且可以抛出异常。
        2.执行callable方式，需要FutureTask实现类的支持，用于接收运算结果，FutureTask是Future接口的实现类
    class SumTask implements Callable<Long> {

        @Override
        public Long call() throws Exception {

            long sum = 0;
            for (int i = 0; i < 9000; i++) {
                sum += i;
            }
            return sum;
        }

        public static void main(String[] args) throws ExecutionException, InterruptedException {
            System.out.println("Start:" + System.nanoTime());
            // 将Callable写的任务封装到一个由执行者调度的FutureTask对象
            FutureTask<Long> futureTask = new FutureTask<Long>(new SumTask());
            // 创建线程池并返回ExecutorService实例 
            Executor executor=Executors.newSingleThreadExecutor();
            //执行任务
            executor.execute(futureTask);
            //打印输出返回值
            System.out.println(futureTask.get());
            System.out.println("End:" + System.nanoTime());
    }

} 
注意点：

避免使用Executors创建线程池，主要是避免使用其中的默认实现，那么我们可以自己直接调用ThreadPoolExecutor的构造函数来自己创建线程池。
在创建的同时，给BlockQueue指定容量就可以了。
private static ExecutorService executor = new ThreadPoolExecutor(10, 10,
60L, TimeUnit.SECONDS,
new ArrayBlockingQueue(10));
这种情况下，一旦提交的线程数超过当前可用线程数时，就会抛出java.util.concurrent.RejectedExecutionException，
这是因为当前线程池使用的队列是有边界队列，队列已经满了便无法继续处理新的请求。
但是异常（Exception）总比发生错误（Error）要好

ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)