JAVA多线程机试试题

最新推荐文章于 2023-02-15 14:44:57 发布
转载 最新推荐文章于 2023-02-15 14:44:57 发布 · 1.9k 阅读 · 3
文章标签：

#JAVA #多线程机试题

          以下题目答案来自传智张孝祥老师多线程讲解视频。

题目一：

原题

package com.fei;

/**
 * 现有的程序代码模拟产生了16个日志对象，并且需要运行16秒才能打印完这些日志，
 * 请在程序中增加4个线程去调用parseLog()方法来分头打印这16个日志对象，
 * 程序只需要运行4秒即可打印完这些日志对象。
 *
 */
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();
		}
	}

}


 

运行结果

begin:1374236125
1:1374236125
2:1374236126
3:1374236127
4:1374236129
5:1374236130
6:1374236131
7:1374236132
8:1374236133
9:1374236134
10:1374236135
11:1374236136
12:1374236137
13:1374236138
14:1374236139
15:1374236140
16:1374236141

修改后：

package com.fei;

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

public class Test {
	
	public static void main(String[] args){
	//	final SynchronousQueue<String> queue = new SynchronousQueue<String>();
        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();
		}		
	}
	
}


 

运行结果

begin:1374236852
1:1374236852
2:1374236852
4:1374236852
3:1374236852
5:1374236853
6:1374236853
7:1374236853
8:1374236853
9:1374236854
10:1374236854
11:1374236854
12:1374236854
13:1374236855
14:1374236855
15:1374236855
16:1374236855

题目二：

原题

package com.fei;
/**
 * 现成程序中的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;
	}
}


运行结果

begin:1374237199
main:0:1374237200
main:1:1374237201
main:2:1374237202
main:3:1374237203
main:4:1374237204
main:5:1374237205
main:6:1374237206
main:7:1374237207
main:8:1374237208
main:9:1374237209

修改：

package com.fei;

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

public class Test02 {

	public static void main(String[] args) {
		final Semaphore semaphore = new Semaphore(1);
	//    final BlockingQueue<String> queue =new ArrayBlockingQueue<String>(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;
	}
}


 

运行结果

begin:1374237419
Thread-0:0:1374237420
Thread-2:1:1374237421
Thread-4:2:1374237422
Thread-6:3:1374237423
Thread-8:4:1374237424
Thread-1:5:1374237425
Thread-3:6:1374237426
Thread-5:7:1374237427
Thread-7:8:1374237428
Thread-9:9:1374237429

题目三：

原题：

package syn;
/**
 * 现有程序同时启动了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();
			}
		}
	}

}


 

运行结果

begin:1374237680
1:2:1374237681
4:4:1374237681
3:3:1374237681
1:1:1374237681

修改：

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

}


 

运行结果

begin:1374237873
1:2:1374237874
4:4:1374237874
3:3:1374237874
1:1:1374237875

 
 

 

java多线程面试50题
weixin_72049402的博客
03-07 371
什么是阻塞队列？Java中有哪些阻塞队列？答：阻塞队列是一种多线程协作的数据结构，它可以在队列已满或空时自动阻塞等待，直到队列可以继续插入或取出元素。Java中常见的阻塞队列包括ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。
38道多线程核心面试题（附答案）
DN金猿的博客
04-16 1940
今天给大家分享的是比较全面的多线程面试题，大家在面试的过程中不免会被问到很多专业性的问题，有的时候回答的并不是那么全面和精细，这仅仅代表个人观点。
Java基础面试题——IO和多线程专题
二蛋的博客
02-15 7864
进程：一个独立的正在执行的程序线程：一个进程的最基本的执行单位，执行路径多进程：在操作系统中，同时运行多个程序多进程的好处：可以充分利用CPU，提高CPU的使用率多线程：在同一个进程(应用程序)中同时执行多个线程多线程的好处：提高进程的执行使用率，提高了CPU的使用率在同一个时间点一个CPU中只可能有一个线程在执行多线程不能提高效率、反而会降低效率，但是可以提高CPU的使用率一个进程如果有多条执行路径，则称为多线程程序Java虚拟机的启动至少开启了两条线程，主线程和垃圾回收线程。
java线程机试_多线程面试题（2020）
weixin_39991055的博客
02-28 327
多线程1.并行和并发有什么区别？并行：多个任务在同一个 CPU 核上，按细分的时间片轮流(交替)执行，从逻辑 上来看那些任务是同时执行。并发：多个处理器或多核处理器同时处理多个任务。如下图：并发和并行 并发 = 两个队列和一台咖啡机。 并行 = 两个队列和两台咖啡机。2.线程和进程的区别？一个程序下至少有一个进程，一个进程下至少有一个线程，一个进程下也可以有 多个线程来增加程序的执行速度。3.守护...
43道多线程面试题，附带答案(二)
chenqueyu8679的博客
07-11 1587
1.线程的sleep()方法和yield()方法有什么区别？ 答： ① sleep()方法给其他线程运行机会时不考虑线程的优先级，因此会给低优先级的线程以运行的机会；yield()方法只会给相同优先级或更高优先级的线程以运行的机会； ② 线程执行sleep()方法后转入阻塞（blocked...
java基本概念Java基础笔试机试测试题
03-24
- `StringBuffer` 类是可变的字符串类，可以安全地用于多线程环境中。 - 方法 `changeString()` 中，传入的 `StringBuffer` 对象被追加了 `"stringbuffer2"`。 - 在 `main` 方法中，调用 `changeString()` 后，`...
211学校计算机考研机试试题Java版本.zip
最新发布
06-20
该压缩包文件“211学校计算机考研机试试题Java版本.zip”主要针对的是准备211高校计算机专业考研的学生，特别聚焦于Java编程语言的相关知识。这些题目可能涵盖计算机科学的基础理论，如数据结构、算法，以及Java编程...
北大青鸟学士后Java毕业考试笔试与机试试题解析
综上所述，本次“北大青鸟学士后毕业考试（Java）笔试和机试”涵盖了Java语言基础、面向对象编程、数据库操作、网络编程、多线程处理、常用开发框架等多个方面的知识内容。通过系统地复习和练习这些知识点，考生不仅...
北大青鸟S1结业考试最新Java机试试题解析
- Java的多线程编程以及并发机制 - Java的新特性，比如Java 8的Lambda表达式和Stream API - Java数据库连接（JDBC）的使用 - Java网络编程，包括Socket编程和HTTP客户端编程 - Java的反射机制及其应用场景 3. ...
Java内部测试笔试_机试试题.zip
03-07
5. **多线程**：Java提供了丰富的多线程支持，包括Thread类、Runnable接口、并发工具类如synchronized、volatile、Lock等。熟悉并发编程的概念，如线程安全、死锁、活锁等，是高并发应用开发的关键。 6. **IO流**：...
一道java多线程笔试上机题
ethanzhou
04-18 458
   上个星期我到诚迈科技参加面试.面试完毕后面试官让我把笔试卷上的一道多线程题在计算机上编程实现.题目如下: 四个线程a,b,c,d. 线程a,b对变量i加一. 线程c,d对变量i减去一.四个线程顺序执行, 每个线程每次只执行一次.i的初始值为0， 打印结果0 1 2 1 0 1 2 1 0 1 2...    这道题还是有一定的难度的. 因为要求顺序执行. 不能简单用同步.    经...
java多线程面试题整理及答案（2019年）
weixin_30569001的博客
02-27 742
1) 什么是线程？ 线程是操作系统能够进行运算调度的最小单位，它被包含在进程之中，是进程中的实际运作单位。程序员可以通过它进行多处理器编程，你可以使用多线程对 运算密集型任务提速。比如，如果一个线程完成一个任务要100毫秒，那么用十个线程完成改任务只需10毫秒。Java在语言层面对多线程提供了卓越的支 持，它也是一个很好的卖点。 2) 线程和进程有什么区别？ 线程是进程的子集，一个进程可以有...
java关于线程的题目_Java多线程的试题
weixin_42397024的博客
02-27 212
一、创建线程的两种方式：1、继承thread类；重写run方法。(单继承，直接写业务逻辑)public class Demo1 extends Thread{@Overridepublic void run{for(int=i; i<100; i++){system.out.println(“自定义线程：”+i)；}}}2、实现Runnable接口，运行run方法来实现线程。class D...
黑马程序员——多线程
黑马程序员-java学习笔记
11-26 538
------- android培训、java培训、期待与您交流！ ----------   一、多线程 1、进程和线程：          进程：正在进行的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。          线程：进程内部的一条执行路径或者一个控制单元。          两者的区别：                    一个进程至
华为机试题：多线程
李志杰的博客
08-13 510
问题重述： 这里考虑原子整型，但是牛客网中原子整型出错，因此改为互斥锁，还是出错，说什么没有链接相应的文件。因此将此问题在此记录。 思路解析： 完全可以用两个变量去控制，这里考虑原子整型，但是牛客网中原子整型出错，因此改为互斥锁，还是出错，说什么没有链接相应的文件。因此将此问题在此记录。思路详见代码： 代码实现： # include<thread> # include<iostream> #include<atomic> #include<vect
Java多线程面试题，我丝毫不慌
热门推荐
3y
07-28 3万+
甚至还有点想笑
java多线程并发相关的一道上机面试题
雷锋叔叔呐
07-31 1301
public class TestAlgorithm1 { /** * 数组A为1,2,3,4,5,6,...52 * 数组B为 26个英文字母 * 用两个线程分别输出12a23b.... * * * * 可以使用自旋锁, lockSupport , 以下使用 自旋锁 */ public stat...
多线程测试题(附答案)
L00teacher的博客
06-11 4911
**多线程** 一、判断题(T为正确,F为错误),每题1分 1.如果线程死亡，它便不能运行。（ T ） 2.在Java中，高优先级的可运行线程会抢占低优先级线程。（ T ） 3.线程可以用yield方法使低优先级的线程运行。（ F ） yield方法：暂停线程，暂停当前正在执行的线程对象。yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。 yield()只能使同优先级或更高优先级的线程有执行的机会。 4.程序开发者必须创建一...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值