第一题
现有的程序代码模拟产生了16个日志对象,并且需要运行16秒才能打印完这些日志,请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象,程序只需要运行4秒即可打印完这些日志对象。原始代码如下:
package read;
public class Test {
public static void main(String[] args){
System.out.println("begin:"+(System.currentTimeMillis()/1000));
/*模拟处理16行日志,下面的代码产生了16个日志对象,当前代码需要运行16秒才能打印完这些日志。
修改程序代码,开四个线程让这16个对象在4秒钟打完。
*/
for(int i=0;i<16;i++){ //这行代码不能改动
final String log = ""+(i+1);//这行代码不能改动
{
Test.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();
}
}
}
分析:
主程序Test类的主方法通过16次循环,产生了16个日志文件,并且调用静态方法parseLog(String log)将日志文件打印出来。打印方法每打印一次用时1秒。题目要求增加4个线程用4秒时间将全部日志文件打印完,所以每个线程要调用4次打印方法才能将16个日志文件在4秒钟内打印。主方法中循环16次不可改动,并且不可以在循环中创建线程,因为如果在循环中创建线程会创建16个线程。注意到在循环中创建的日志文件是一个局部变量,所以要用一个容器将产生的日志文件保存起来。我想到用一个容量为16的String数组将日志文件保存。然后每个线程取出数组中的日志文件并调用parseLog方法并将其打印出来。
我的程序
public class Test {
public static void main(String[] args){
System.out.println("begin:"+(System.currentTimeMillis()/1000));
/*模拟处理16行日志,下面的代码产生了16个日志对象,当前代码需要运行16秒才能打印完这些日志。
修改程序代码,开四个线程让这16个对象在4秒钟打完。
*/
//用String数组将产生的日志缓存起来
final String[] buf = new String[16];
for(int i=0;i<16;i++){ //这行代码不能改动
final String log = ""+(i+1);//这行代码不能改动
{
//Test.parseLog(log);
//将日志文件放到String数组中保存起来
buf[i] = log;
}
}
//新建并启动四个线程
for(int i = 0; i < 4; i++){
final int temp = i;
new Thread(){
@Override
public void run() {
//每一个线程创建4个日志对象
for(int j = 0; j < 4; j++){
parseLog(buf[temp*4+j]);
}
}
}.start();
}
}
//parseLog方法内部的代码不能改动
public static void parseLog(String log){
System.out.println(log+":"+(System.currentTimeMillis()/1000));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行
张老师答案:
张老师用的是一个阻塞队列ArrayBlockingQueue将日志文件存储,然后打印。看到打印的日志顺序更加顺序化。
public class Test {
public static void main(String[] args){
final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(16);
System.out.println("begin:"+(System.currentTimeMillis()/1000));
/*模拟处理16行日志,下面的代码产生了16个日志对象,当前代码需要运行16秒才能打印完这些日志。
修改程序代码,开四个线程让这16个对象在4秒钟打完。
*/
for(int i=0;i<16;i++){ //这行代码不能改动
final String log = ""+(i+1);//这行代码不能改动
{
//Test.parseLog(log);
try {
//将日志文件存储到queue中
queue.put(log);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
for(int i = 0; i < 4; i++){
new Thread(){
@Override
public void run() {
try {
for(int j = 0; j < 4; j++){
//从queue中取出日志并打印
String log = queue.take();
parseLog(log);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}.start();
}
}
//parseLog方法内部的代码不能改动
public static void parseLog(String log){
System.out.println(log+":"+(System.currentTimeMillis()/1000));
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
运行
第二题
现成程序中的Test类中的代码在不断地产生数据,然后交给TestDo.doSome()方法去处理,就好像生产者在不断地产生数据,消费者在不断消费数据。请将程序改造成有10个线程来消费生成者产生的数据,这些消费者都调用TestDo.doSome()方法去进行处理,故每个消费者都需要一秒才能处理完,程序应保证这些消费者线程依次有序地消费数据,只有上一个消费者消费完后,下一个消费者才能消费数据,下一个消费者是谁都可以,但要保证这些消费者线程拿到的数据是有顺序的。原始代码如下:
public class Test {
public static void main(String[] args) {
System.out.println("begin:"+(System.currentTimeMillis()/1000));
for(int i=0;i<10;i++){ //这行不能改动
String input = i+""; //这行不能改动
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;
}
}
因为主程序循环10次产生10个input,并且要求创建10个线程并调用TestDo.doSome()方法,所以想到直接在循环中创建线程。
我的错误答案:
又因为要实现线程的互斥,保证这些消费者线程依次有序地消费数据,想到创建一个单线程池并且在循环中创建Runnable对象作为10个不同的线程并作为target传到线程池并运行。这样实现了线程的有序运行,但是忽略了虽然创建了10个不同的Runnable对象但是线程池只有一个线程,不符合题目要求的10个线程。看程序。
public class Test {
public static void main(String[] args) {
//一个单线程池
ExecutorService pool = Executors.newFixedThreadPool(1);
System.out.println("begin:"+(System.currentTimeMillis()/1000));
for(int i=0;i<10;i++){ //这行不能改动
String input = i+""; //这行不能改动
//String output = TestDo.doSome(input);
//System.out.println(Thread.currentThread().getName()+ ":" + output);
//因为匿名内部类要用到局部变量input
//所以定义一个final修饰的myInput并将赋予input的值
final String myInput = input;
//创建Runable匿名对象并赋给target
Runnable target = new Runnable() {
@Override
public void run() {
String output = TestDo.doSome(myInput);
System.out.println(Thread.currentThread().getName()+ ":" + output);
}
};
//将target交由线程池执行
pool.execute(target);
}
//关闭线程池
pool.shutdown();
}
}
//不能改动此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;
}
}
运行看到只有一个线程
修改:
要使用10个线程并且要有序运行,需要使用一个信号类Semaphore以控制10个线程的运行。
public class Test {
public static void main(String[] args) {
//信号类控制线程运行
final Semaphore semaphore = new Semaphore(1);
System.out.println("begin:"+(System.currentTimeMillis()/1000));
for(int i=0;i<10;i++){ //这行不能改动
String input = i+""; //这行不能改动
//String output = TestDo.doSome(input);
//System.out.println(Thread.currentThread().getName()+ ":" + output);
final String myInput = input;
new Thread(){
@Override
public void run() {
try {
//多个线程并发操作要先获取信号才可继续运行
semaphore.acquire();
String output = TestDo.doSome(myInput);
System.out.println(Thread.currentThread().getName()+ ":" + output);
//运行完后释放信号
semaphore.release();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}.start();
}
}
}
//不能改动此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;
}
}
运行
10条线程每隔1秒运行一次。
第三题
现有程序同时启动了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不同,则并行执行(相互之间不互斥)。原始代码如下:
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 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;
}
public void doSome(Object key, String value) {
// 以大括号内的是需要局部同步的代码,不能改动!
{
try {
Thread.sleep(1000);
System.out.println(key+":"+value + ":"
+ (System.currentTimeMillis() / 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
分析:
因为要求在TestDo.doSome方法中,当每个线程中指定的key相等时,这些相等key的线程应每隔一秒依次输出时间值,需要用互斥,所以要在doSome中增加同步代码块并且使用合适的锁以便互斥。如果使用key作为锁,由于在Test类中其构造方法将内容相同的字符串也改变为两个不同的对象,所以不可以实现key内容相同时互斥。所以要想办法将内容相同的key变成同一个对象。
我的错误答案:
因为要将内容相同的key变成一个对象,所以想到使用HashSet,因为将添加到HashSet中的元素不可以内容重复,即内容相同的两个对象只会添加一个,所以取出时就是一个对象,这样,就可以将key作为锁使用同步了。
但是我忽略了HashSet是线程不安全的,线程并发访问时会出现安全隐患。
//不能改动此Test类
public class Test1 extends Thread{
private TestDo testDo;
private String key;
private String value;
public Test1(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{
Test1 a = new Test1("1","","1");
Test1 b = new Test1("1","","2");
Test1 c = new Test1("3","","3");
Test1 d = new Test1("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 Set<Object>set = new HashSet<Object>();
private TestDo() {}
private static TestDo _instance = new TestDo();
public static TestDo getInstance() {
return _instance;
}
public void doSome(Object key, String value) {
set.add(key);
Iterator<Object> it = set.iterator();
Object myKey = null;
while(it.hasNext()){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String str = (String)it.next();
if(str.equals(key)){
myKey = str;
}
}
synchronized(myKey)
// 以大括号内的是需要局部同步的代码,不能改动!
{
try {
Thread.sleep(1000);
System.out.println(key+":"+value + ":"
+ (System.currentTimeMillis() / 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行
如果在遍历时让线程睡眠,则会出现异常。因为线程并发访问HashSet会出现安全隐患:多线程并发访问的情况下,迭代的同时不可以向HashSet中添加元素。
修改:
不使用线程不安全的HashSet而使用JDK1.5提供的线程安全的ConcurrentSkipListSet。
//不能改动此Test类
public class Test1 extends Thread{
private TestDo testDo;
private String key;
private String value;
public Test1(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{
Test1 a = new Test1("1","","1");
Test1 b = new Test1("1","","2");
Test1 c = new Test1("3","","3");
Test1 d = new Test1("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 {
//使用线程安全的ConcurrentSkipListSet
private ConcurrentSkipListSet<Object>set = new ConcurrentSkipListSet<Object>();
private TestDo() {}
private static TestDo _instance = new TestDo();
public static TestDo getInstance() {
return _instance;
}
public void doSome(Object key, String value) {
//将key添加进set,如果set中包含内容重复的元素则不添加
set.add(key);
Iterator<Object> it = set.iterator();
Object myKey = null;
while(it.hasNext()){
try {
Thread.sleep(20);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
String str = (String)it.next();
//找到set中与key内容相同的元素,将其赋给myKey作为锁
if(str.equals(key)){
myKey = str;
}
}
synchronized(myKey)
// 以大括号内的是需要局部同步的代码,不能改动!
{
try {
Thread.sleep(1000);
System.out.println(key+":"+value + ":"
+ (System.currentTimeMillis() / 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
运行
张老师答案:
张老师使用的是线程安全的CopyOnWriteArrayList,将key添加进集合,如果集合中已经包含了该key,那么将集合中的该元素作为锁,这样当key内容相同时使用的锁就会是同一个对象了。
//不能改动此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 {
//使用线程安全的CopyOnWriteArrayList
private CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<Object>();
private TestDo() {}
private static TestDo _instance = new TestDo();
public static TestDo getInstance() {
return _instance;
}
public void doSome(Object key, String value) {
Object myKey = key;
//如果list中不包含myKey,那么添加
if(!list.contains(myKey)){
list.add(myKey);
}else{
//否则,找到与key内容相同的元素并取出
//遍历list
for(Iterator<Object> it = list.iterator();it.hasNext();){
Object obj = it.next();
//找到内容相同的元素
if(obj.equals(key)){
//将obj赋给myKey
myKey = obj;
break;
}
}
}
//使用myKey作为锁
synchronized(myKey)
// 以大括号内的是需要局部同步的代码,不能改动!
{
try {
Thread.sleep(1000);
System.out.println(key+":"+value + ":"
+ (System.currentTimeMillis() / 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}