前面针对多线程相关知识点进行了学习,那么我们来来看看常见的面试题:

1. 空中网面试题1  

package com.kongzhongwang.interview;  

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue; //myeclipse强大功能:将代码直接复制到项目的src路径下可以自动相应生成包名和类名
/**
*
* 空中网面试题1:现有程序代码模拟产生16个日志对象,并且需要运行16秒才能打印完这些日志,请在程序中增加四个线程去调用
* parseLog()方法来分头打印这16个日志对象,程序只需运行4秒即可打印完这些日志对象。
* 考察新技术BlockingQueue
*/ public class ReadLog {
public static void main(String[] args) { /*此处有一个巧合:这里ArrayBlockingQueue<String>(1)和ArrayBlockingQueue<String>(16)
* 达到的效果一样,并且前者产生的数据组合更整齐;目前推测是巧合,希望大牛发现因果了告知一声
*/
final BlockingQueue<String> queue = new ArrayBlockingQueue<String>(1);
for (int i = 0; i < 4; i++) {
new Thread(new Runnable() {
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); // 这行代码不能改动
{
// ReadLog.parseLog(log);
try {
queue.put(log);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
} // parseLog内部代码不能动
public static void parseLog(String log) {
System.out.println(log + ":" + System.currentTimeMillis() / 1000);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
2. 空中网面试题2 package com.kongzhongwang.interview; import java.util.concurrent.Semaphore;
import java.util.concurrent.SynchronousQueue; /**
* 空中网面试题2: 现成程序中的Test类中的代码在不断地产生数据,然后交给TestDo.doSome()方法去处理;
* 这就好像是生产者在不断地产生数据,消费者在不断地消费数据。请将程序改造成有10个线程来消费生产者产生的数据,
* 这些消费者都调用TestDo.doSome()方法去处理,固每个消费者都需要1秒才能处理完,程序应该保证这些
* 消费者线程依次有序的消费数据,只有上一个消费者消费完后,下一个消费者才能消费数据,下一个消费者是谁都可以, 但要保证消费者拿到的数据是有顺序的。
*/
public class Test { public static void main(String[] args) { //使用semaphore信号灯相当于上一个lock锁
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) {
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();
}
}
}
} // TestDo类不能动
class TestDo { public static String doSome(String input) {
try {
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
String output = input + ":" + (System.currentTimeMillis() / 1000);
return output;
} }
3.空中网面试题3 package com.kongzhongwang.interview; import java.util.ArrayList;
import java.util.Iterator;
import java.util.concurrent.CopyOnWriteArrayList; public class Tests extends Thread { /**
* 空中网面试题3: 现有程序同时启动了四个线程去调用TestDo.doSome(key,value)方法;
* 由于TestsDo.doSome(key,value)方法内的代码是先暂停1秒,然后再输出以秒为单位的当前时间值,
* 所以会打印出四个相同的时间值,如下所示:4:4 1258199615 1:1 1258199615 3:3 1258199615 2:2
* 1258199615 ;请修改代码,如果有几个线程调用TestDo.doSome(key,value)方法时;
* 传递进去的key值相等(equals比较为true),则这几个线程应互斥输出结果,即当有两个线程的key都为1时,
* 它们中的一个要比其他线程晚一步输出结果,如下所示:4:4 1258199615 1:1 1258199615 3:3 1258199615 1:2
* 1258199616 ;总之每个线程中指定的key相等时;这些相等的线程应每隔1秒输出时间值(要用互斥),
* key不同,则并行执行(相互之间不互斥)
*/ private TestsDo testDo;
private String key;
private String value; private Tests(String key, String key2, String value) {
this.testDo = TestsDo.getInstance();
/*
* 常量“1”和“1”是同一个对象,下面这行代码就是要用“1”+“”的方式产生新的对象;
* 以实现内容没有改变,仍然相等(都还为“1”),但对象却不再是同一个的效果
*/
this.key = key + key2;
/*
* a = "1"+"";
* b = "2"+"";
* a和b是同一个对象,因为编译器在执行之前就会将其优化为 a=“1”;
* 但是this.key = key + key2;这句,编译器不会给你优化,
* 因为你是属性变量,编译器不知道你将来要传入什么值
*/
this.value = value;
} public static void main(String[] args) { Tests a = new Tests("1", "", "1");
Tests b = new Tests("1", "", "2");
Tests c = new Tests("3", "", "3");
Tests d = new Tests("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 TestsDo {
private TestsDo() {}
private static TestsDo _instance = new TestsDo();
public static TestsDo 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();){
/*这里的休眠作用:为了让大家看到,使用传统的private ArrayList keys = new ArrayList();
* 会导致Exception in thread "Thread-1" java.util.ConcurrentModificationException异常
* 因为迭代的过程中不能进行其他操作;你非要在迭代的时候向其中添加数据就会导致这种异常,而且在迭代中放入休眠这种错误百发百中。
*/
try {
Thread.sleep(20);
} catch (InterruptedException e) {
e.printStackTrace();
}
Object oo = iter.next();
if(o.equals(oo)){
o = oo;
}
}
}
//这里为了区别是不同对象,所以不能直接使用synchronized(key)
synchronized(o)
//大括号内的是需要同步的代码,不能改动
{
try{
Thread.sleep(1000);
System.out.println(key+":"+value+":" + (System.currentTimeMillis() / 1000));
}catch(Exception e){
e.printStackTrace();
}
}
}
}

其它面试题:

https://www.cnblogs.com/Jansens520/p/8624708.html

Java多线程常用面试题(含答案,精心总结整理)

JAVA多线程提高十四: 面试题的更多相关文章

  1. JAVA多线程提高十四:同步工具Exchanger

    Exchanger可以在对中对元素进行配对和交换的线程的同步点.每个线程将条目上的某个方法呈现给 exchange 方法,与伙伴线程进行匹配,并且在返回时接收其伙伴的对象.Exchanger 可能被视 ...

  2. “全栈2019”Java多线程第二十四章:等待唤醒机制详解

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java多 ...

  3. “全栈2019”Java多线程第十四章:线程与堆栈详解

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java多 ...

  4. JAVA多线程提高十:同步工具CyclicBarrier与CountDownLatch

    今天继续学习其它的同步工具:CyclicBarrier与CountDownLatch 一.CyclicBarrier CyclicBarrier是一个同步辅助类,它允许一组线程互相等待,直到到达某个公 ...

  5. JAVA多线程提高十二:阻塞队列应用

    一.类相关属性 接口BlockingQueue<E>定义: public interface BlockingQueue<E> extends Queue<E> { ...

  6. Java多线程(十四):Timer

    Timer schedule(TimerTask task, Date time) 该方法在指定日期执行任务,如果是过去的时间,这个任务会立即被执行. 执行时间早于当前时间 示例代码,当前时间是201 ...

  7. Java多线程学习(四)等待/通知(wait/notify)机制

    转载请备注地址:https://blog.csdn.net/qq_34337272/article/details/79690279 系列文章传送门: Java多线程学习(一)Java多线程入门 Ja ...

  8. Java进阶(三十四)Integer与int的种种比较你知道多少?

    Java进阶(三十四)Integer与int的种种比较你知道多少? 前言 如果面试官问Integer与int的区别:估计大多数人只会说到两点:Ingeter是int的包装类,注意是一个类:int的初值 ...

  9. “全栈2019”Java多线程第二十九章:可重入锁与不可重入锁详解

    难度 初级 学习时间 10分钟 适合人群 零基础 开发语言 Java 开发环境 JDK v11 IntelliJ IDEA v2018.3 文章原文链接 "全栈2019"Java多 ...

随机推荐

  1. windows下的C++ socket服务器(4)

    void handleAccept(int socket_fd) { ] = { '\0' }; string cmd; string filename; recv(socket_fd, buf, ) ...

  2. 数据库:XML,解析Dom4J

    package com.itheima.util; import java.io.FileOutputStream; import java.net.URL; import org.dom4j.Doc ...

  3. Vue2.0组件之间通信(转载)

    Vue中组件这个特性让不少前端er非常喜欢,我自己也是其中之一,它让前端的组件式开发更加合理和简单.笔者之前有写过一篇Vue2.0子父组件通信,这次我们就来聊一聊平级组件之间的通信. 首先我们先搭好开 ...

  4. Beta阶段团队项目开发篇章3

    例会时间 2016.12.6晚 例会照片 个人工作 上阶段任务验收 中英文切换功能已经实现,调查结果分析已经完成,博客基本撰写完成,在征求其他组员意见后发布.任务基本完成. 任务分配 组员 任务内容 ...

  5. Delphi 使用TAdoQuery执行存储过程的样例

    procedure TCustomerForm.FindCustomerInfo;var  strSql:string;begin //  BL_HV_FindCustomerInfo 存储过程的名称 ...

  6. 面试问题总结二(技术能力-PHP)----Ⅰ

    1.你都做过什么项目? 答:第一份实习工作接触的项目是CRM 销售管理系统,一款用JSP语言开发的进销存管理系统.第一份正式工作是一款主打高质量图片社交社区网站项目,“美啦周末”(后改型为”聊会儿”) ...

  7. Python学习笔记day01--Python基础

    1 python的应用     Python崇尚优美.清晰.简单,是一个优秀并广泛使用的语言.     Python可以应用于众多领域,如:数据分析.组件集成.网络服务.图像处理.数值计算和科学计算等 ...

  8. Dubbo学习(九) Dubbo面试问题

    Dubbo是Alibaba开源的分布式服务框架,它最大的特点是按照分层的方式来架构,使用这种方式可以使各个层之间解耦合(或者最大限度地松耦合). 从服务模型的角度来看,Dubbo采用的是一种非常简单的 ...

  9. 数据库事务的四大特性以及4种事务的隔离级别-以及对应的5种JDBC事务隔离级别

    本篇讲诉数据库中事务的四大特性(ACID),并且将会详细地说明事务的隔离级别. 如果一个数据库声称支持事务的操作,那么该数据库必须要具备以下四个特性: ⑴ 原子性(Atomicity) 原子性是指事务 ...

  10. spring的jar包以及相关的API文档的下载方式

    转自:http://blog.csdn.net/yuexianchang/article/details/53583327 侵删 感谢原创 首先是进入官网:https://spring.io/ 如图所 ...