Java线程(七):JUC包同步集合及JUC总结练习

时间:2021-10-12 11:10:12

一、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();
				}
			}
		}

	}