空中网面试题

最新推荐文章于 2024-04-10 21:04:00 发布

Git猫

最新推荐文章于 2024-04-10 21:04:00 发布

阅读量982

点赞数

文章标签：空中网面试题

本文链接：https://blog.csdn.net/ypkobe24/article/details/17489189

版权

第一题

现有的程序代码模拟产生了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不同，则并行执行（相互之间不互斥）。原始代码如下：

//不能改动此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();
			}
		}
	}
}