学习java多线程的笔记4--传智播客_张孝祥_空中网挑选实习生的面试题(来源于视频)

最新推荐文章于 2021-02-21 11:31:14 发布
最新推荐文章于 2021-02-21 11:31:14 发布
阅读量4.1k 收藏
点赞数
分类专栏： 学习java笔记 文章标签： 面试 多线程 java string semaphore output
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangqinjiang/article/details/7435512
版权

摘自传智播客_张孝祥_空中网挑选实习生的面试题 视频教程的,(主要是线程与队列的使用).

与本人无关,仅供以后参考使用大笑


空中网4k/5k月薪挑选大四实习生的线程题
    两年前，我们一个大四的学员去应聘空中网的实习生职位，空中网只给他出了三道线程题，拿回家做两天后再去给经理讲解，如果前两题做好了给4k月薪，第三道题也做出来的话就给5k的月薪。这样的实习薪水和招聘要求，不需要有工作经验的限制，纯粹是技术功底的比拼和考核，而不像许多其他公司非要招两年工作经验的人，逼得那些刚毕业和未毕业的大学生不得不去撒谎，不得不去做假简历，甚至假毕业证！所以，空中网的这份工作对未毕业的大学生来说，还是很有吸引力的。这个学生是否入职空中网，大家去猜吧，免得有人看不顺眼而叫骂，呵呵！
    第一题：现有的程序代码模拟产生了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();
            }        
        }
        
    }

修改后的代码如下:

package read;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class Test {
	
	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) {
							// TODO Auto-generated catch block
							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) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
	     			//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类中的代码在不断地产生数据，然后交给TestDo.doSome()方法去处理，就好像生产者在不断地产生数据，消费者在不断消费数据。请将程序改造成有10个线程来消费生成者产生的数据，这些消费者都调用TestDo.doSome()方法去进行处理，故每个消费者都需要一秒才能处理完，程序应保证这些消费者线程依次有序地消费数据，只有上一个消费者消费完后，下一个消费者才能消费数据，下一个消费者是谁都可以，但要保证这些消费者线程拿到的数据是有顺序的。原始代码如下：

    
package queue;
    
    public class Test3 {
    
        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;
        }
    }

修改后的代码如下:

package queue;

import java.util.concurrent.Semaphore;
import java.util.concurrent.SynchronousQueue;

public class Test {

	public static void main(String[] args) {
		final Semaphore semaphore = new Semaphore(1);
		final SynchronousQueue<String> queue = new SynchronousQueue<String>();
		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) {
						// TODO Auto-generated catch block
						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) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

//不能改动此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个线程去调用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 syn;

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

    }

修改后的代码如下:

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

}



    有兴趣的网友可以努力做做这些题，我不久将公布我的解答和相应的讲解视频。
 大家只要将上面任何一题的完整代码复制到eclipse中的某个工程的src目录下，就可以自动生成包名和文件名，运行该程序就可以观察到程序修改前的运行效果。


qin江
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
张孝祥java多线程视频笔记----传统线程互斥技术
08-19 751
//子线程循环10次，接着主线程循环100次，接着在子线程循环10次，接着再主线程循环100次 public class SynTest { public static void main(String[] args) { final Business b=new Business(); new Thread( new Runnable(){ @Override pu
张孝祥Java多线程与并发库高级应用笔记
01-25
观看视频时所做的笔记，重点内容都做了记录
笔记_张孝祥_Java多线程与并发库高级应用
03-28
张孝祥Java多线程与并发库高级应用学习笔记，很经典的学习多线程和并发的资料。张孝祥Java多线程讲义笔记由张孝祥亲自整理，很实用的。
JAVA_Lesson13(传智播客笔记之多线程）
wearlee的博客
07-02 461
多线程的状态创建线程的第一种方式—继承Thread类（其实就是覆盖run方法，然后调用自己的show方法）创建线程的第二种方式—实现Runnable接口      但是人家万一已经有爹了，那就没法了。不支持多继承。此时要拓展该类的功能，创建接口。让其中的内容作为线程的任务执行。接口就是为了实现拓展功能；一个类在继承一个类的同时，也可以实现多个接口，为了这个类增加多个功能。通过接口的形式完成（拓展D...
张孝祥 java多线程_张孝祥老师-java并发编程听课笔记（三）
weixin_39947501的博客
02-21 161
第六讲ThreadLocal实现线程范围内的共享ThreadLocal相当于一个哈希public class ThreadLocalTest{private static ThreadLocal x = new ThreadLocal();public static void main(String[] args){for (int i = 0; i < 2; i++){new Thread...
传智播客_张孝祥_Java邮件开发教程
08-26
根据提供的文件信息，我们可以深入探讨有关“传智播客_张孝祥_Java邮件开发教程”的相关知识点。这里将重点介绍Java邮件开发的基础概念、应用场景以及实现方式。 ### Java邮件开发简介 Java邮件开发主要是利用Java...
传智播客_张孝祥_传统线程同步通信技术
01-07
张孝祥老师的课程"传智播客_张孝祥_传统线程同步通信技术"深入浅出地讲解了这一主题，旨在帮助开发者理解和掌握线程间的协作与数据共享方式。 线程同步是指在多线程环境下，控制多个线程按一定的顺序执行，以避免...
传智播客_张孝祥_Java Web_XML基础
08-26
传智播客_张孝祥_Java Web_XML基础，讲解非常详细，值得一看
传智播客_张孝祥_java基础教程\1\Java培训教程教学课件.rar
11-02
标题和描述中提到的“传智播客_张孝祥_java基础教程\1\Java培训教程教学课件.rar”是这个压缩文件的命名，它揭示了这是一个由传智播客机构推出的，由讲师张孝祥主讲的Java编程基础教程。这个课程可能包含了多个部分...
Java多线程与并发库高级应用--20_传智播客_张孝祥_空中网挑选实习生的面试题1 原创：徐工 2018-5- 6 22.30
xwx7712的专栏
05-07 246
Java多线程与并发库高级应用--20_传智播客_张孝祥_空中网挑选实习生的面试题1原创：徐工2018-5- 6 22.30package read;import java.util.concurrent.ArrayBlockingQueue;import java.util.concurrent.BlockingQueue;public class Test { public static v...
【张孝祥并发课程笔记】06：多线程共享数据的方式探讨
litchemine的专栏
03-02 450
TODO
多线程Demo-空中网面试题（张孝祥讲解）
kuyuyingzi的专栏
02-06 3037
摘自传智播客_张孝祥_空中网挑选实习生的面试题 视频教程的,(主要是线程与队列的使用). 与本人无关,仅供以后参考使用 空中网4k/5k月薪挑选大四实习生的线程题     两年前，我们一个大四的学员去应聘空中网的实习生职位，空中网只给他出了三道线程题，拿回家做两天后再去给经理讲解，如果前两题做好了给4k月薪，第三道题也做出来的话就给5k的月薪。这样的实习薪水和招聘要求，不需要
java多线程笔记
dark
01-21 211
近期重温了一遍张孝祥老师的java多线程学习视频，粗略记录一下学习笔记。 一、多线程的实现 extends Thread (示例略) implements Runnable new Thread(new Runnable() { @Override public void run() { while(true){ outpu
java多线程笔记(一)
堕落者的博客
02-22 270
什么是进程? 是程序执行的过程 持有资源(内存)和线程 是动态性的 什么是线程? 系统中执行的最小单元 同一个进程有多个线程 线程共享进程的资源 ------------------------------------- 线程的交互 : 互斥 同步 ...
Java 高级 多线程 Thread Runnable Synchronize Lock 6大线程状态 线程池（结合传智黑马与狂神）总结
CTRA®王大大技术中心
07-01 279
1、创建一个线程过程 线程创建的二个方式： 继承 Thread 类 实现 Runnable 接口 （推荐 ☆） 1.1 首先继承 Thread类 // 方式一：继承 Thread 类 （不推荐） public class ThreadDemo1 extends Thread{} 1.2 重写 run() 方法 ☆ 这里是线程的核心操作方法，一切线程的操作都放在这里 // run方法线程主体 public void run() { for (int i = 0; i < 200; i++)
空中网多线程面试题3
胡小海丶
07-07 902
 第三题：现有程序同时启动了4个线程去调用TestDo.doSome(key, value)方法，由于TestDo.doSome(key, value)方法内的代码是先暂停1秒，然后再输出以秒为单位的当前时间值，所以，会打印出4个相同的时间值，如下所示：   4:4:1258199615   1:1:1258199615   3:3:1258199615   1:2:12581996
Java张孝祥视频 学习笔记 多线程
，，，，的博客
03-01 4029
此博客主要是在观看张孝祥老师的教学视频的过程中，自己所做的学习笔记，在此以博客的形式分享出来，方便大家学习 参考资料 传智播客_张孝祥_Java多线程与并发库高级应用视频教程下载 视频下载
学习java多线程的笔记1--Thread(Runnable t)与重写run()方法等
yangqinjiang的专栏
03-26 9003
今天看了看《Java2核心技术卷II：高级特性》中的--多线程--这一篇，还有看了张孝祥老师的Java多线程与并发库高级应用视频。顺便做个笔记，方便以后复习一下java相关知识： 关于线程Thread类中的  Thread(Runnable target) 构造方法的使用 代码一： package cn.yang.thread; public class ThradTest2 {
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值