线程问题

 线程同步

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,该关键字是同步锁,用于将某段代码变为同步操作,从而解决线程并发安全问题。

复制代码
 1 /**
 2  * 线程安全问题
 3  *多线程并发访问同一段数据的时候  就会产生线程安全问题
 4  *解决办法:  把异步操作变成同步操作(先后顺序)
 5  *synchronized  同步锁   也有人叫 互斥锁
 6  */
 7 class SynDemo{
 8     public static void main(String[] args) {
 9         final Table table =new Table();
10         Thread t1 =new Thread(){
11             @Override
12             public void run() {
13                 while(true){
14                     System.out.println(getName()+":"+table.getBean());
15                     Thread.yield();
16                 }
17             }
18         };
19         
20         Thread t2=new Thread(){
21             @Override
22             public void run() {
23                 while(true){
24                     System.out.println(getName()+":"+table.getBean());
25                     Thread.yield();
26                 }
27             }
28         };
29         t1.start();
30         t2.start();
31         
32     }
33 }
34 class Table{
35     //桌子上有20个桌子
36     private int beans =20;
37     //从桌子上取出一个豆子
38     public synchronized int getBean(){
39         if(beans==0){
40             throw new RuntimeException("没有豆子了");
41         }
42         Thread.yield();//主动让cpu回到Runnable
43         return beans--;
44     }
45 }
46 /**
47  * 线程安全的互斥问题
48  * @author Administrator
49  *当一个类中多个方法被synchronize修饰时 这些方法一般是互斥的
50  */
复制代码

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的方法 就要将该对象加锁

 

复制代码
 1 /**
 2   * wait 和notify方法
 3   * 这两个方法是定义在Object上的
 4   */
 5  class WaitAndNotify{
 6      private static boolean isFinish =false;
 7      public static void main(String[] args) {
 8         //用一个对象测试wait和notify
 9          final Object obj =new Object();
10          //下载线程
11          final Thread download =new Thread(){
12              @Override
13             public void run() {
14                 System.out.println("图片开始下载:");
15                 for(int i=0;i<50;i++){
16                     System.out.println("图片下载%"+i);
17                     try {
18                         Thread.sleep(10);
19                     } catch (InterruptedException e) {
20                         // TODO Auto-generated catch block
21                         e.printStackTrace();
22                     }
23                 }
24                 System.out.println("图片下载完毕");
25                 isFinish=true;
26                 
27                 //通知显示线程可以开始工作了
28                 synchronized (obj) {
29                     //obj.notifyAll();  随机选择线程 解除阻塞
30                     obj.notify();
31                 }
32                 System.out.println("附件开始下载:");
33                 for(int i=0;i<50;i++){
34                     System.out.println("附件下载%"+i);
35                     try {
36                         Thread.sleep(10);
37                     } catch (InterruptedException e) {
38                         // TODO Auto-generated catch block
39                         e.printStackTrace();
40                     }
41                 }
42                 System.out.println("附件下载完毕");
43             }
44          };
45          
46          Thread show =new Thread(){
47              @Override
48             public void run() {
49                  System.out.println("开始显示图片");
50 //                 try {
51 //                    download.join();
52 //                } catch (InterruptedException e) {
53 //                    // TODO Auto-generated catch block
54 //                    e.printStackTrace();
55 //                }
56                  //在obj对象上等待
57                  try {
58                      synchronized (obj) {
59                          /*
60                           * wait方法要求:
61                           * 调用哪个对象的wait的方法 就要将该对象加锁
62                           */
63                          obj.wait();
64                     }
65                 } catch (InterruptedException e) {
66                     // TODO Auto-generated catch block
67                     e.printStackTrace();
68                 }
69                  
70                 if(isFinish){
71                     System.out.println("图片显示成功");
72                 }else{System.out.println("图片显示失败");}
73             }
74          };
75          download.start();
76          show.start();
77          
78     }
79  }
复制代码

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();
        
    }
 }
 
posted @ 2015-05-11 15:17  Rozdy  阅读(399)  评论(0编辑  收藏  举报