线程同步

 线程同步

1.synchronized

2.wait、notify

3.线程安全与非安全

　　StringBuffer 、StringBuilder

　　Vector、Hashtable

　　ArrayList、HashMap

　　Collections.synchonizedList()

　　Collections.synchronizedMap()

4.ExecutorService

5.BlockingQueue

----------------------------------------------------------------------------

1. synchronized同步锁
synchronized 
1.可以修饰方法 被修饰的方法 称为同步方法
2.synchronized修饰代码块,用于同步某一块代码码片段的， 通常synchronized块的范围要小于synchronized方法

多个线程并发读写同一个临界资源时候会发生"线程并发安全问题“
常见的临界资源:
多线程共享实例变量
多线程共享静态公共变量
若想解决线程安全问题，需要将异步的操作变为同步操作。

何为同步？那么我们来对比看一下什么是同步什么异步。
所谓异步操作是指多线程并发的操作，相当于各干各的。
所谓同步操作是指有先后顺序的操作，相当于你干完我再干。

而java中有一个关键字名为:synchronized,该关键字是同步锁，用于将某段代码变为同步操作，从而解决线程并发安全问题。

/**
 * 线程安全问题
 *多线程并发访问同一段数据的时候  就会产生线程安全问题
 *解决办法：  把异步操作变成同步操作（先后顺序）
 *synchronized  同步锁   也有人叫 互斥锁
 */
class SynDemo{
    public static void main(String[] args) {
        final Table table =new Table();
        Thread t1 =new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println(getName()+":"+table.getBean());
                    Thread.yield();
                }
            }
        };
        
        Thread t2=new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println(getName()+":"+table.getBean());
                    Thread.yield();
                }
            }
        };
        t1.start();
        t2.start();
        
    }
}
class Table{
    //桌子上有20个桌子
    private int beans =20;
    //从桌子上取出一个豆子
    public synchronized int getBean(){
        if(beans==0){
            throw new RuntimeException("没有豆子了");
        }
        Thread.yield();//主动让cpu回到Runnable
        return beans--;
    }
}
/**
 * 线程安全的互斥问题
 * @author Administrator
 *当一个类中多个方法被synchronize修饰时 这些方法一般是互斥的
 */

2. 锁机制

Java提供了一种内置的锁机制来支持原子性：
同步代码块(synchronized 关键字 )，使用同步块的目的： 在于缩小同步范围来提高并发效率

同步代码块包含两部分：
a、作为锁的对象的引用，
b、作为由这个锁保护的代码块。

synchronized (同步监视器—锁对象引用this){ 
　　//代码块
} 

通常 同步监视器-锁对象引用 写的是this
若方法所有代码都需要同步也可以给方法直接加锁。
每个Java对象都可以用做一个实现同步的锁，线程进入同步代码块之前会自动获得锁，并且在退出同步代码块时怎释放锁，而且无论是通过正常路径退出锁还是通过抛异常退出都一样，获得内置锁的唯一途径就是进入由这个锁保护的同步代码块或方法。

3. 选择合适的锁对象

使用synchroinzed需要对一个锁对象上锁以保证线程同步。
那么这个锁对象应当注意:多个需要同步的线程在访问该同步块时，看到的应该是同一个所对象引用。否则达不到同步效果。通常我们会使用this来作为锁对象。
同步块要想有同步效果，多线程看到的同步锁对象，必须是同一个

4. 选择合适的锁范围

在使用同步块时，应当尽量在允许的情况下减少同步范围，以提高并发的执行效率。

5. 静态方法锁

当我们对一个静态方法加锁，如:

public synchronized static void xxx(){
….
}

那么该方法锁的对象是类对象。每个类都有唯一的一个类对象。获取类对象的方式:类名.class。
静态方法与非静态方法同时声明了synchronized，他们之间是非互斥关系的。
原因在于，静态方法锁的是类对象而非静态方法锁的是当前方法所属对象。
静态方法上锁以后 同步是跨对象的

**
 * 静态方法锁
 * 静态方法上锁后，同步是跨对象的
 * @author Administrator
 *
 */
 public class StaticDemo {
     public static void main(String[] args) {
        
    }
    public void methodA(){
        String name =Thread.currentThread().getName();
        System.out.println(name+"调用了methodA方法");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            System.out.println("调用MethodA方法完毕");
        }
    }
    public synchronized static void methodB(){
        String name =Thread.currentThread().getName();
        System.out.println(name+"调用了methodB静态方法");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            System.out.println("调用MethodB方法完毕");
        }
    }
}

 
 class TestDemo{
     public static void main(String[] args) {
        final StaticDemo sd1 =new StaticDemo();
        final StaticDemo sd2 =new StaticDemo();
        Thread t1 =new Thread(){
            @Override
            public void run() {
                sd1.methodB();
            }
        };
        Thread t2 =new Thread(){
            @Override
            public void run() {
                sd2.methodB();
            }
        };
        
        t1.start();
        t2.start();
        
    }
 }

/**
  * 编写计时线程，每隔5秒钟输出当前的日期-时间，
  * 主线程结束后计时完毕
  * @author Administrator
  *
  */
 class Homework1{
     /*
      * 1.创建一个线程 用于计时
      * 2.线程计时 
      *      2.1 创建SimpleDateFormate
      *      2.2循环一下操作
      *      2.3创建Date实例 表示系统时间
      *      2.4使用SimpleDateFormate将Date转换为字符串输出
      *      2.5阻塞线程5000毫秒
      * 3.设置线程为守护线程
      * 4.线程启动
      * 5.为了保证守护线程可以运行一段时间 我们阻塞main线程10秒钟
      */
     public static void main(String[] args) {
         
        
         Thread t1 =new Thread(){
             @Override
            public void run() {
                 while(true){
                         SimpleDateFormat sdf =new SimpleDateFormat("yy-MM-dd HH:mm:ss");
                        Date now =new Date();
                        System.out.println(sdf.format(now));
                        try {
                            Thread.sleep(3000);
                        } catch (InterruptedException e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }
                    }
            }
         };
         t1.setDaemon(true);
         t1.start();
         try {
            //如果不阻塞main 只剩下守护进程的时候 gc直接调出 结束进程了
             Thread.sleep(10000000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
         
    }
 }

6、wait和notify

多线程之间需要协调工作。
例如，浏览器的一个显示图片的 displayThread想要执行显示图片的任务，必须等待下载线程downloadThread将该图片下载完毕。如果图片还没有下载完，displayThread可以暂停，当downloadThread完成了任务后，再通知displayThread“图片准备完毕，可以显示了”，这时，displayThread继续执行。
以上逻辑简单的说就是：如果条件不满足，则等待。当条件满足时，等待该条件的线程将被唤醒。
在Java中，这个机制的实现依赖于wait/notify。等待机制与锁机制是密切关联的。

wait 　　 （阻塞）　　　　 可以在当前对象身上等待
notify 　 （解除阻塞） 　　 调用哪个对象的notify方法 就可以让在该对象身上等待的线程继续运行

join比较被动 需要都运行完 才会 解除阻塞
wait方法要求： 调用哪个对象的wait的方法 就要将该对象加锁

/**
  * wait 和notify方法
  * 这两个方法是定义在Object上的
  */
 class WaitAndNotify{
     private static boolean isFinish =false;
     public static void main(String[] args) {
        //用一个对象测试wait和notify
         final Object obj =new Object();
         //下载线程
         final Thread download =new Thread(){
             @Override
            public void run() {
                System.out.println("图片开始下载：");
                for(int i=0;i<50;i++){
                    System.out.println("图片下载%"+i);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                System.out.println("图片下载完毕");
                isFinish=true;
                
                //通知显示线程可以开始工作了
                synchronized (obj) {
                    //obj.notifyAll();  随机选择线程 解除阻塞
                    obj.notify();
                }
                System.out.println("附件开始下载：");
                for(int i=0;i<50;i++){
                    System.out.println("附件下载%"+i);
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                System.out.println("附件下载完毕");
            }
         };
         
         Thread show =new Thread(){
             @Override
            public void run() {
                 System.out.println("开始显示图片");
//                 try {
//                    download.join();
//                } catch (InterruptedException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
                 //在obj对象上等待
                 try {
                     synchronized (obj) {
                         /*
                          * wait方法要求：
                          * 调用哪个对象的wait的方法 就要将该对象加锁
                          */
                         obj.wait();
                    }
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                 
                if(isFinish){
                    System.out.println("图片显示成功");
                }else{System.out.println("图片显示失败");}
            }
         };
         download.start();
         show.start();
         
    }
 }

7. 线程安全API与非线程安全API

之前学习的API中就有设计为线程安全与非线程安全的类:
StringBuffer 是同步的 synchronized append(); 安全的
StringBuilder 不是同步的 append();
相对而言StringBuffer在处理上稍逊于StringBuilder,但是其是线程安全的。当不存在并发时首选应当使用StringBuilder。
同样的:
Vector 和 Hashtable 是线程安全的
ArrayList 和 HashMap则不是线程安全的。
对于集合而言，Collections提供了几个静态方法，可以将集合或Map转换为线程安全的:
例如:
Collections.synchronizedList() :获取线程安全的List集合
Collections.synchronizedMap():获取线程安全的Map
...
List<String> list = new ArrayList<String>();
list.add("A");
list.add("B");
list.add("C");
list = Collections.synchronizedList(list);//将ArrayList转换为线程安全的集合
System.out.println(list);//[A,B,C] 可以看出，原集合中的元素也得以保留
...

/**
  * 转换线程安全的集合和Map
  */
 class SynCollectionAndMap{
    public static void main(String[] args) {
         //List集合
         List<String> list =new ArrayList<String>();
         list.add("a");
         list.add("b");
         list.add("c");
         //转换为线程安全的List集合
         list =Collections.synchronizedList(list);
         /*
          * 能保证：对集合元素进行操作的方法都是同步且
          *         互斥的。保证了线程的安全
          * 注意：在遍历的过程中，依然可以增删元素
          * 解决办法： 对遍历的代码片段加锁，锁的是集合这个对象
          */
         System.out.println(list);
         synchronized (list) {
            java.util.Iterator<String> it = list.iterator();
            while(it.hasNext()){
                System.out.println(it.next());
            }
        }
         //Set集合
         Set<String> set =new HashSet<String>();
         set.add("a");
         set.add("b");
         set.add("c");
         //将Set集合转换为线程安全的
         set = Collections.synchronizedSet(set);
         System.out.println(set);
         
         
         Map<String,Integer> map =new HashMap<String, Integer>();
         map.put("张三",22);
         map.put("赵四",22);
         map.put("王五",22);
         //将Map转换为一个线程安全的
         map=Collections.synchronizedMap(map);
         System.out.println(map);
    }
 }
 

8. 使用ExecutorService实现线程池

当一个程序中若创建大量线程，并在任务结束后销毁，会给系统带来过度消耗资源，以及过度切换线程的危险，从而可能导致系统崩溃。为此我们应使用线程池来解决这个问题。
ExecutorService是java提供的用于管理线程池的类。

线程池有两个主要作用:
1.控制线程数量
2.重用线程

线程池的概念：首先创建一些线程，它们的集合称为线程池，当服务器接受到一个客户请求后，就从线程池中取出一个空闲的线程为之服务，
服务完后不关闭该线程，而是将该线程还回到线程池中。
在线程池的编程模式下，任务是提交给整个线程池，而不是直接交给某个线程，线程池在拿到任务后，它就在内部找有无空闲的线程，再把任务交给内部某个空闲的线程，任务是提交给整个线程池，一个线程同时只能执行一个任务，但可以同时向一个线程池提交多个任务

线程池有以下几种实现策略:
Executors.newCachedThreadPool()
创建一个可根据需要创建新线程的线程池，但是在以前构造的线程可用时将重用它们。
Executors.newFixedThreadPool(int nThreads)
创建一个可重用固定线程集合的线程池，以共享的无界队列方式来运行这些线程。
Executors.newScheduledThreadPool(int corePoolSize)
创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行。
Executors.newSingleThreadExecutor()
创建一个使用单个 worker 线程的 Executor，以无界队列方式来运行该线程。
可以根据实际需求来使用某种线程池。例如，创建一个有固定线程数量的线程池：
...
ExecutorService threadPool
= Executors.newFixedThreadPool(30);//创建具有30个线程的线程池
Runnable r1 = new Runable(){
public void run(){
//线程体
}
};
threadPool.execute(r1);//将任务交给线程池，其会分配空闲线程来运行这个任务。
...

/**
  * 测试线程池
  * @author Administrator
  *
  */
 
 class TestThreadPoolDemo{
     public static void main(String[] args) {
        //创建了一个含有10个线程的线程池
         ExecutorService threadpool = Executors.newFixedThreadPool(2);
         for(int i=0;i<5;i++){
             Handler handler =new Handler();
             threadpool.execute(handler); 
         }
         System.out.println("任务全部指派完成");
    }
 }
 /*
  * 线程要执行的任务
  */
 class Handler implements Runnable{
     @Override
    public void run() {
         //获取运行当前任务的线程名字
         String name =Thread.currentThread().getName();
         System.out.println("运行当前任务的线程是："+name);
         for(int i=0;i<10;i++){
             System.out.println(name+":"+i);
             try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
         }
         System.out.println("任务完毕");
    }
 }

9. BlockingQueue双缓冲队列

queue 一边进一边出
Deque 两边都能进都能出

BlockingQueue是双缓冲队列、BlockingDeque是双缓冲双端队列

在多线程并发时，若需要使用队列，我们可以使用Queue，但是要解决一个问题就是同步，但同步操作会降低并发对Queue操作的效率。
BlockingQueue内部使用两条队列，可允许两个线程同时向队列一个做存储，一个做取出操作。在保证并发安全的同时提高了队列的存取效率。

双缓冲队列有一下几种实现:
ArrayBlockingDeque:规定大小的BlockingDeque,其构造函数必须带一个int参数来指明其大小.其所含的对象是以FIFO(先入先出)顺序排序的。

LinkedBlockingDeque:大小不定的BlockingDeque,若其构造函数带一个规定大小的参数,生成的BlockingDeque有大小限制,若不带大小参数,所生成的BlockingDeque的大小由Integer.MAX_VALUE来决定.其所含的对象是以FIFO(先入先出)顺序排序的。

PriorityBlockingDeque:类似于LinkedBlockDeque,但其所含对象的排序不是FIFO,而是依据对象的自然排序顺序或者是构造函数的Comparator决定的顺序。

SynchronousQueue:特殊的BlockingQueue,对其的操作必须是放和取交替完成的。

/**
  * 双缓冲队列
  */
 class TestBlockingQueueDemo{
     public static void main(String[] args) {
         /*
          * 双缓冲队列，创建一个固定长度的，里面存放10个元素
          * 该队列是单向的，遵循先进先出的原则
          */
        final BlockingQueue<Integer> queue =new ArrayBlockingQueue<Integer>(10);
        /*
         * 双缓冲双端队列，与单队列的区别在于，队列两端都可以进出队
         */
//        BlockingDeque<Integer> Deque =new LinkedBlockingDeque<Integer>(10);
        
        //向队列中添加元素的线程
        Thread offerThread =new Thread(){
            @Override
            public void run() {
                for(int i=0;i<20;i++){
                    //局部变量使用前必须初始化
                    boolean tf = false;
                    try {
                        /*
                         * 该方法允许我们设置一个延迟时间
                         * 在延迟时间之后还没放入 便返回false
                         */
                        tf=queue.offer(i,5,TimeUnit.SECONDS);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("添加元素"+i+":"+tf);
                }
            }
        };
        
        offerThread.start();
        
        //从队列中取出元素的线程
        Thread pullThread=new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                for(int i=0;i<20;i++){
                    int num=0;
                    try {
                        num=queue.poll(5,TimeUnit.SECONDS);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("取出的元素是："+num);
                }
            }
        };
        
        
        pullThread.start();
        
    }
 }