一、JUC包同步集合
1、日常使用的集合,如ArrayList 、 HashMap 等是不安全的
2、在迭代集合的时候不能对集合作修改。
3、案例:
package com.newThread; import java.util.ArrayList; import java.util.Collection; import java.util.Iterator; import java.util.concurrent.CopyOnWriteArrayList; /** * * CollectionModifyExceptionTest.java * * @title 集合异常测试,同步集合类 * @description * 1-在迭代集合的时候不能对集合作修改: * 2-CopyOnWriteArrayList 允许迭代时可以修改与删除 * @author SAM-SHO * @Date 2014-8-31 */ public class CollectionModifyExceptionTest { public static void main(String[] args) { // Collection<User> users = new CopyOnWriteArrayList<User>(); Collection<User> users = new ArrayList<User>(); users.add(new User("张三",28)); users.add(new User("李四",25)); users.add(new User("王五",31)); Iterator <User>itrUsers = users.iterator(); //迭代集合 while(itrUsers.hasNext()){ System.out.println("aaaaaaaaaaa"); User user = (User)itrUsers.next(); if("张三".equals(user.getName())){ users.remove(user); } else { System.out.println(user); } } } }
1)分析:报错,java.util.ConcurrentModificationException 。
2)modCount为操作集合的次数,如集合增加三个元素,则为3,删除一个后为4。expectedModCount 为一迭代前modCount的值。迭代的时候,next()-->checkForComodification()-->modCount != expectedModCount 抛出 ConcurrentModificationException。
3)在迭代集合的时候不能对集合作修改。但是JUC包的 CopyOnWriteArrayList 可以解决。
二、JUC总结练习
1、阻塞队列的使用:
package com.test; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; /* * 第一题:现有的程序代码模拟产生了16个日志对象,并且需要运行16秒才能打印完这些日志, * 请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象, * 程序只需要运行4秒即可打印完这些日志对象。 * 原始代码如下: */ public class ThreadLogTest { public static void main(String[] args){ //创立阻塞队列 final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1); for(int i=0;i<4;i++){ new Thread(new Runnable(){ @Override public void run() { while(true){ try { String log = queue.take();//队列取值 parseLog(log); } catch (InterruptedException e) { e.printStackTrace(); } } } }).start(); } System.out.println("begin:"+(System.currentTimeMillis()/1000)); /*模拟处理16行日志,下面的代码产生了16个日志对象,当前代码需要运行16秒才能打印完这些日志。 修改程序代码,开四个线程让这16个对象在4秒钟打完。 */ for(int i=0;i<16;i++){ //这行代码不能改动 final String log = ""+(i+1);//这行代码不能改动 { try { queue.put(log);//主线程队列放值 } catch (InterruptedException e) { e.printStackTrace(); } // ThreadLogTest.parseLog(log); } } } //parseLog方法内部的代码不能改动 public static void parseLog(String log){ System.out.println(log+":"+(System.currentTimeMillis()/1000)); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } }
2、生产者与消费者
package com.test; import java.util.concurrent.ArrayBlockingQueue; import java.util.concurrent.BlockingQueue; import java.util.concurrent.Semaphore; /* * 第二题:现成程序中的Test类中的代码在不断地产生数据,然后交给TestDo.doSome()方法去处理, * 就好像生产者在不断地产生数据,消费者在不断消费数据。 * 请将程序改造成有10个线程来消费生成者产生的数据,这些消费者都调用TestDo.doSome()方法去进行处理, * 故每个消费者都需要一秒才能处理完,程序应保证这些消费者线程依次有序地消费数据,只有上一个消费者消费完后, * 下一个消费者才能消费数据,下一个消费者是谁都可以,但要保证这些消费者线程拿到的数据是有顺序的。 * 原始代码如下: */ public class ProduceAndConsumeTest { public static void main(String[] args) { final Semaphore semaphore = new Semaphore(1);//并发交通灯(Lock也可以) //同步队列(阻塞队列都可以实现) // final SynchronousQueue<String> queue = new SynchronousQueue<String>(); final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1); for (int i = 0; i < 10; i++) { new Thread(new Runnable(){ @Override public void run() { try { semaphore.acquire();//拿到阻塞 String input = queue.take();//从队列中拿 String output = TestDo.doSome(input); System.out.println(Thread.currentThread().getName()+ ":" + output); semaphore.release();//释放 } catch (InterruptedException e) { e.printStackTrace(); } } }).start(); } System.out.println("begin:"+(System.currentTimeMillis()/1000)); for(int i=0;i<10;i++){ //这行不能改动 String input = i+""; //这行不能改动 try { queue.put(input);//往队列中放入 } catch (InterruptedException e) { e.printStackTrace(); } // String output = TestDo.doSome(input); // System.out.println(Thread.currentThread().getName()+ ":" + output); } } } //不能改动此TestDo类 class TestDo { public static String doSome(String input){ try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } String output = input + ":"+ (System.currentTimeMillis() / 1000); return output; } }
3、同步集合:
package com.test; import java.util.Iterator; import java.util.concurrent.CopyOnWriteArrayList; /* *第三题:现有程序同时启动了4个线程去调用TestDo.doSome(key, value)方法, * 由于TestDo.doSome(key, value)方法内的代码是先暂停1秒,然后再输出以秒为单位的当前时间值, * 所以,会打印出4个相同的时间值,如下所示: 4:4:1258199615 1:1:1258199615 3:3:1258199615 1:2:1258199615 请修改代码,如果有几个线程调用TestDo.doSome(key, value)方法时, 传递进去的key相等(equals比较为true),则这几个线程应互斥排队输出结果, 即当有两个线程的key都是"1"时,它们中的一个要比另外其他线程晚1秒输出结果, 如下所示: 4:4:1258199615 1:1:1258199615 3:3:1258199615 1:2:1258199616 总之,当每个线程中指定的key相等时,这些相等key的线程应每隔一秒依次输出时间值(要用互斥), 如果key不同,则并行执行(相互之间不互斥)。原始代码如下: */ //不能改动此Test类 public class Test extends Thread{ private ThirdTestDo testDo; private String key; private String value; public Test(String key,String key2,String value){ this.testDo = ThirdTestDo.getInstance(); /*常量"1"和"1"是同一个对象,下面这行代码就是要用"1"+""的方式产生新的对象, 以实现内容没有改变,仍然相等(都还为"1"),但对象却不再是同一个的效果*/ // this.key = key; 这样就可以互斥,是同一个引用 this.key = key+key2; //这边是不同的的引用 this.value = value; } public static void main(String[] args) throws InterruptedException{ Test a = new Test("1","","1"); Test b = new Test("1","","2"); Test c = new Test("3","","3"); Test d = new Test("4","","4"); System.out.println("begin:"+(System.currentTimeMillis()/1000)); a.start(); b.start(); c.start(); d.start(); } public void run(){ testDo.doSome(key, value); } } class ThirdTestDo { private ThirdTestDo() {} private static ThirdTestDo _instance = new ThirdTestDo(); public static ThirdTestDo getInstance() { return _instance; } // private ArrayList<Object> keys = new ArrayList<Object>(); private CopyOnWriteArrayList<Object> keys = new CopyOnWriteArrayList<Object>();//使用线程安全 public void doSome(Object key, String value) { Object o = key; if(!keys.contains(o)) {//contains 就是equals 集合中没有该对象 keys.add(o);//往集合装东西,当有线程在遍历时,这时就会报错,所以换容器 }else{ // for(Iterator<Object> its = keys.iterator(); its.hasNext(); ) {//遍历集合 try { Thread.sleep(20);//慢点迭代,这样就可以并发集合操作 } catch (InterruptedException e) { e.printStackTrace(); } Object obj = its.next(); if(obj.equals(o)){ o = obj;//这时的 obj 与 key 即是我们需要的一组对象 } } } synchronized (o)//锁定该对象 // 以大括号内的是需要局部同步的代码,不能改动! { try { Thread.sleep(1000); System.out.println(key+":"+value + ":" + (System.currentTimeMillis() / 1000)); } catch (InterruptedException e) { e.printStackTrace(); } } } }