1. 可阻塞队列——BlockingQueue
队列包含固定长度的队列与不固定长度的队列。
BlockingQueue是一个接口,它支持两个附加操作的 Queue
,这两个操作是:获取元素时等待队列变为非空,以及存储元素时等待空间变得可用。
1.1 API
1.1.1 插入
1. add(e):当队列已满的时候,用add就会抛异常
2. offer(e):如果队列已满,用offer添加的时候,会返回false。
3. put(e):如果队列已满,用put添加的时候,程序会阻塞,直到可以插入为止。
4. offer(e,time,unit)
1.1.2 移除
1. remove():当队列为空的时候,用remove就会抛异常
2. poll():当队列为空的时候,用poll的时候,会返回null
3. take():当队列为空的时候,用take程序会阻塞,直到队列不为空为止。
4. poll(time,unit)
1.1.3 检查
1. element():获取,但是不移除此队列的头,队列为空时将抛出一个异常
2. peek():获取但不移除此队列的头;如果此队列为空,则返回 null。
例如:
package com.bjc.thread.demo6;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueTest {
public static void main(String[] args) {
final BlockingQueue queue = new ArrayBlockingQueue(3);
for(int i=0;i<2;i++){
new Thread(){
public void run(){
while(true){
try {
Thread.sleep((long)(Math.random()*1000));
System.out.println(Thread.currentThread().getName() + "准备放数据!");
queue.put(1);
System.out.println(Thread.currentThread().getName() + "已经放了数据," +
"队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
new Thread(){
public void run(){
while(true){
try {
//将此处的睡眠时间分别改为100和1000,观察运行结果
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "准备取数据!");
queue.take();
System.out.println(Thread.currentThread().getName() + "已经取走数据," +
"队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
1.2 阻塞队列的简单应用
1. 用两个具有1个空间的队列来实现同步通知的功能。
Business.java
package com.bjc.thread.demo6;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
* 思路:
* 1. 创建两个长度为1的阻塞队列
* 2. 默认让队列2为满队列
* 3. 通过阻塞队列的API的可阻塞方法来实现线程的通信
*
*/
public class Business {
private BlockingQueue<Integer> q1 = new ArrayBlockingQueue<Integer>(1);
private BlockingQueue<Integer> q2 = new ArrayBlockingQueue<Integer>(1);
// 可以理解为匿名的构造函数,该代码块先于构造函数执行
{
try {
// 创建对象的时候,让q2队列为满队列
q2.put(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void sub() throws Exception{
// 往q1队列放入元素
q1.put(1);
for(int i = 0 ; i < 3; i++){
System.out.println(" sub");
}
// q2队列取出元素
q2.take();
}
public void main() throws Exception{
// 往q2队列放入元素
q2.put(1);
for(int i = 0 ; i < 5; i++){
System.out.println("main");
}
// q1队列取出元素
q1.take();
}
}
测试方法:
package com.bjc.thread.demo6;
public class BlockingQueuCom {
public static void main(String[] args) {
Business b = new Business();
new Thread(){
@Override
public void run() {
try {
for(int i = 0 ; i < 10 ; i++){
b.sub();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}.start();
new Thread(){
@Override
public void run() {
try {
for(int i = 0 ; i < 10 ; i++){
b.main();
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}.start();
}
}
运行结果:
2. 现有的程序代码模拟产生了16个日志对象,并且需要运行16秒才能打印完这些日志,请在程序中增加4个线程去调parseLog()方法来分头打印这16个日志对象,程序只需要运行4秒即可打印完这些日志对象
package com.bjc.test;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
* @author Administrator
* 现有的程序代码模拟产生了16个日志对象,并且需要运行16秒才能打印完这些日志,
* 请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象,
* 程序只需要运行4秒即可打印完这些日志对象
*
*/
public class Demo1 {
public static void main(String[] args) throws Exception{
BlockingQueue<String> queue = new ArrayBlockingQueue<String>(4);
for(int i = 0 ; i < 4 ; i++){
new Thread(){
@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);//这行代码不能改动
{
queue.put(log);
}
}
}
//parseLog方法内部的代码不能改动
public static void parseLog(String log){
System.out.println(log+":"+(System.currentTimeMillis()/1000));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
3. 现成程序中的Test类中的代码在不断地产生数据,然后交给TestDo.doSome()方法去处理,就好像生产者在不断地产生数据,消费者在不断消费数据。请将程序改造成有10个线程来消费生成者产生的数据,这些消费者都调用TestDo.doSome()方法去进行处理,故每个消费者都需要一秒才能处理完,程序应保证这些消费者线程依次有序地消费数据,只有上一个消费者消费完后,下一个消费者才能消费数据,下一个消费者是谁都可以,但要保证这些消费者线程拿到的数据是有顺序的
package com.bjc.test;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Semaphore;
import java.util.concurrent.SynchronousQueue;
/**
* @author Administrator
* 现成程序中的Test类中的代码在不断地产生数据,然后交给TestDo.doSome()方法去处理,
* 就好像生产者在不断地产生数据,消费者在不断消费数据。请将程序改造成有10个线程来消费生成者产生的数据,
* 这些消费者都调用TestDo.doSome()方法去进行处理,故每个消费者都需要一秒才能处理完,
* 程序应保证这些消费者线程依次有序地消费数据,只有上一个消费者消费完后,下一个消费者才能消费数据,
* 下一个消费者是谁都可以,但要保证这些消费者线程拿到的数据是有顺序的
*/
public class Demo2 {
public static void main(String[] args) throws Exception {
// 定义一个信号量,用于让一次只有一个线程执行
Semaphore semaphore = new Semaphore(1);
// 定义一个同步队列
BlockingQueue<String> queue = new SynchronousQueue<String>();
for(int i = 0 ; i < 10 ; i++){
new Thread(){
@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+""; //这行不能改动
// String output = TestDo.doSome(input);
queue.put(input);
}
}
}
//不能改动此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;
}
}
4. 现有程序同时启动了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不同,则并行执行(相互之间不互斥)
我的解题方法:
package com.bjc.demo3;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
//不能改动此Test类
public class Test extends Thread{
private TestDo testDo;
private String key;
private String value;
public Test(String key,String key2,String value){
this.testDo = TestDo.getInstance();
/*常量"1"和"1"是同一个对象,下面这行代码就是要用"1"+""的方式产生新的对象,
以实现内容没有改变,仍然相等(都还为"1"),但对象却不再是同一个的效果*/
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 TestDo {
private TestDo() {}
private static TestDo _instance = new TestDo();
public static TestDo getInstance() {
return _instance;
}
private List<Object> list = new ArrayList<Object>();
public void doSome(Object key, String value) {
// 注意这里不能仅仅加synchronized同步,因为每次传递过来的key都是不同的对象,所以需要处理
Object o = key;
if(!list.contains(o)){
list.add(key);
} else {
// 这里不能用list.indexOf(o)来获取对象的下标,因为多线程的原因,集合的大小会改变
// 所以这里用迭代器
while(list.iterator().hasNext()){
try {
Thread.sleep(30);
Object o1 = list.iterator().next();
if(o1.equals(o)){
o = o1;
break;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
synchronized (o)
// 以大括号内的是需要局部同步的代码,不能改动!
{
try {
Thread.sleep(1000);
System.out.println(key+":"+value + ":"
+ (System.currentTimeMillis() / 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
标准答案:
package syn;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList;
//不能改动此Test类
public class Test extends Thread{
private TestDo testDo;
private String key;
private String value;
public Test(String key,String key2,String value){
this.testDo = TestDo.getInstance();
/*常量"1"和"1"是同一个对象,下面这行代码就是要用"1"+""的方式产生新的对象,
以实现内容没有改变,仍然相等(都还为"1"),但对象却不再是同一个的效果*/
this.key = key+key2;
/* a = "1"+"";
b = "1"+""
*/
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 TestDo {
private TestDo() {}
private static TestDo _instance = new TestDo();
public static TestDo getInstance() {
return _instance;
}
//private ArrayList keys = new ArrayList();
private CopyOnWriteArrayList keys = new CopyOnWriteArrayList();
public void doSome(Object key, String value) {
Object o = key;
if(!keys.contains(o)){
keys.add(o);
}else{
for(Iterator iter=keys.iterator();iter.hasNext();){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
Object oo = iter.next();
if(oo.equals(o)){
o = oo;
break;
}
}
}
synchronized(o)
// 以大括号内的是需要局部同步的代码,不能改动!
{
try {
Thread.sleep(1000);
System.out.println(key+":"+value + ":"
+ (System.currentTimeMillis() / 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
注意:标准答案使用的是CopyOnWriteArrayList并发容器
2. 并发集合
未完待续。。。。。。