`
coolxing
  • 浏览: 874186 次
  • 性别: Icon_minigender_1
  • 来自: 北京
博客专栏
9a45b66b-c585-3a35-8680-2e466b75e3f8
Java Concurre...
浏览量：97287
社区版块
存档分类
最新评论

java并发编程--一道经典多线程题的2种解法

java锁同步趣题java多线程 
阅读更多 
coolxing按: 转载请注明作者和出处, 如有谬误, 欢迎在评论中指正.]

问题的描述

启动3个线程打印递增的数字, 线程1先打印1,2,3,4,5, 然后是线程2打印6,7,8,9,10, 然后是线程3打印11,12,13,14,15. 接着再由线程1打印16,17,18,19,20....以此类推, 直到打印到75. 程序的输出结果应该为:

 

线程1: 1

线程1: 2

线程1: 3

线程1: 4

线程1: 5

 

线程2: 6

线程2: 7

线程2: 8

线程2: 9

线程2: 10

...

 

线程3: 71

线程3: 72

线程3: 73

线程3: 74

线程3: 75

 

 

解法一: 采用原始的synchronized, wait(), notify(), notifyAll()等方式控制线程.

 

public class NumberPrintDemo {
	// n为即将打印的数字
	private static int n = 1;
	// state=1表示将由线程1打印数字, state=2表示将由线程2打印数字, state=3表示将由线程3打印数字
	private static int state = 1;

	public static void main(String[] args) {
		final NumberPrintDemo pn = new NumberPrintDemo();
		new Thread(new Runnable() {
			public void run() {
				// 3个线程打印75个数字, 单个线程每次打印5个连续数字, 因此每个线程只需执行5次打印任务. 3*5*5=75
				for (int i = 0; i < 5; i++) {
					// 3个线程都使用pn对象做锁, 以保证每个交替期间只有一个线程在打印
					synchronized (pn) {
						// 如果state!=1, 说明此时尚未轮到线程1打印, 线程1将调用pn的wait()方法, 直到下次被唤醒
						while (state != 1)
							try {
								pn.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						// 当state=1时, 轮到线程1打印5次数字
						for (int j = 0; j < 5; j++) {
							// 打印一次后n自增
							System.out.println(Thread.currentThread().getName()
									+ ": " + n++);
						}
						System.out.println();
						// 线程1打印完成后, 将state赋值为2, 表示接下来将轮到线程2打印
						state = 2;
						// notifyAll()方法唤醒在pn上wait的线程2和线程3, 同时线程1将退出同步代码块, 释放pn锁. 
						// 因此3个线程将再次竞争pn锁
						// 假如线程1或线程3竞争到资源, 由于state不为1或3, 线程1或线程3将很快再次wait, 释放出刚到手的pn锁. 
						// 只有线程2可以通过state判定, 所以线程2一定是执行下次打印任务的线程.
						// 对于线程2来说, 获得锁的道路也许是曲折的, 但前途一定是光明的.
						pn.notifyAll();
					}
				}
			}
		}, "线程1").start();

		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 5; i++) {
					synchronized (pn) {
						while (state != 2)
							try {
								pn.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						for (int j = 0; j < 5; j++) {
							System.out.println(Thread.currentThread().getName()
									+ ": " + n++);
						}
						System.out.println();
						state = 3;
						pn.notifyAll();
					}
				}
			}
		}, "线程2").start();

		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 5; i++) {
					synchronized (pn) {
						while (state != 3)
							try {
								pn.wait();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						for (int j = 0; j < 5; j++) {
							System.out.println(Thread.currentThread().getName()
									+ ": " + n++);
						}
						System.out.println();
						state = 1;
						pn.notifyAll();
					}
				}
			}
		}, "线程3").start();
	}
}

 

解法二: 采用JDK1.5并发包提供的Lock, Condition等类的相关方法控制线程.

 

public class NumberPrint implements Runnable {
	private int state = 1;
	private int n = 1;
	// 使用lock做锁
	private ReentrantLock lock = new ReentrantLock();
	// 获得lock锁的3个分支条件
	private Condition c1 = lock.newCondition();
	private Condition c2 = lock.newCondition();
	private Condition c3 = lock.newCondition();

	@Override
	public void run() {
		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 5; i++) {
					try {
						// 线程1获得lock锁后, 其他线程将无法进入需要lock锁的代码块.
						// 在lock.lock()和lock.unlock()之间的代码相当于使用了synchronized(lock){}
						lock.lock();
						while (state != 1)
							try {
								// 线程1竞争到了lock, 但是发现state不为1, 说明此时还未轮到线程1打印. 
								// 因此线程1将在c1上wait
								// 与解法一不同的是, 三个线程并非在同一个对象上wait, 也不由同一个对象唤醒
								c1.await();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						// 如果线程1竞争到了lock, 也通过了state判定, 将执行打印任务
						for (int j = 0; j < 5; j++) {
							System.out.println(Thread.currentThread().getName()
									+ ": " + n++);
						}
						System.out.println();
						// 打印完成后将state赋值为2, 表示下一次的打印任务将由线程2执行
						state = 2;
						// 唤醒在c2分支上wait的线程2
						c2.signal();
					} finally {
						// 打印任务执行完成后需要确保锁被释放, 因此将释放锁的代码放在finally中
						lock.unlock();
					}
				}
			}
		}, "线程1").start();

		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 5; i++) {
					try {
						lock.lock();
						while (state != 2)
							try {
								c2.await();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						for (int j = 0; j < 5; j++) {
							System.out.println(Thread.currentThread().getName()
									+ ": " + n++);
						}
						System.out.println();
						state = 3;
						c3.signal();
					} finally {
						lock.unlock();
					}
				}
			}
		}, "线程2").start();

		new Thread(new Runnable() {
			public void run() {
				for (int i = 0; i < 5; i++) {
					try {

						lock.lock();
						while (state != 3)
							try {
								c3.await();
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
						for (int j = 0; j < 5; j++) {
							System.out.println(Thread.currentThread().getName()
									+ ": " + n++);
						}
						System.out.println();
						state = 1;
						c1.signal();
					} finally {
						lock.unlock();
					}
				}
			}
		}, "线程3").start();
	}
	
	public static void main(String[] args) {
		new NumberPrint().run();
	}
}

 

总结: 对比解法一和解法二, 显然解法二是更好的解决方案. 解法一的问题在于无法进行精确唤醒, 比如线程1执行完打印任务并调用pn.notifyAll()方法后, 3个线程将再次竞争锁, 而不是精确唤醒线程2. 虽然线程2最终将赢得锁, 下一次的打印任务也肯定会由线程2执行, 但是竞争的持续时间是不可预知的, 只能看线程2的人品.

最糟糕的情形可以是: 线程3竞争到了锁, 紧接着wait. 接下来线程1也竞争到了锁, 然后线程1也wait. 此时就再也没有其他线程跟线程2竞争了, 线程2终于艰难的赢得了锁...

 

留下3个问题供有兴趣的朋友思考:

1. 解法一和解法二中的while (state != xx)是否可以换成if(state != xx), 为什么?

2. 解法一的中的pn.notifyAll()是否可以换成pn.notify(), 为什么?

3. 是否可以用wait(), notify(), notifyAll()等方法完成类似解法二的精确唤醒, 请给出方案或代码.--这个问题我思考了很久, 却没有头绪. 关键的困难在于必须调用pn的wait()方法和notifyAll()方法, 而不能是其他对象的wait()和notifyAll()方法. 如果你有思路, 还望在博客中留言, 不甚感激!

 

 

 

7
顶
3
踩
分享到：
| java并发编程--线程池初步
评论
18 楼 yuanliangding 2016-08-02  
第二题，解法二，是可以换成if的吧。
因为休眠了，没有人唤醒是不会起来的。
这里又是精确唤醒。上一家只有自己的完全搞定了才会来唤醒。
17 楼 u014087707 2016-02-20  
         
16 楼 zhutulang 2014-12-28  
Mojarra 写道
搂主的第二种思路具有很高的研究价值

对于第一种方法，我这里有个思路要简单些，这个题目其实是3个运行中的线程，在某一个时刻只有一是可以打印数字的，其他2个都必须是等待状态。给每一个线程一个id，state表示打印序列，75/5/3，可以得出来共有15个打印序列，如果state%3==id,表示当前线程可以打印，否则必须等到一个可打印的序列完成才可以进行下一轮循环。那么可以在方法级上用synchronized关键字声明。虽然有线程竞争的情形出现，但不会出现思锁。

class NumberPrinter extends Thread {
	static int c = 0;
	static int state = 0;
	private int id;

	@Override
	public synchronized void run() {
		while (state < 15) {
			if (state % 3 == id) {
				for (int j = 0; j < 5; j++) {
					c++;
					System.out.format("Thread %d: %d %n", id, c);
				}
				state++;
			}
		}
	}

	public NumberPrinter(int id) {
		this.id = id;
	}

	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {
			new NumberPrinter(i).start();
		}
	}
}


这段代码有问题，会产生死循环。可以把state 变量改为 volatile  state
15 楼 zhubinhua 2013-06-05  
coolxing 写道
Mojarra 写道
搂主的第二种思路具有很高的研究价值

对于第一种方法，我这里有个思路要简单些，这个题目其实是3个运行中的线程，在某一个时刻只有一是可以打印数字的，其他2个都必须是等待状态。给每一个线程一个id，state表示打印序列，75/5/3，可以得出来共有15个打印序列，如果state%3==id,表示当前线程可以打印，否则必须等到一个可打印的序列完成才可以进行下一轮循环。那么可以在方法级上用synchronized关键字声明。虽然有线程竞争的情形出现，但不会出现思锁。

class NumberPrinter extends Thread {
	static int c = 0;
	static int state = 0;
	private int id;

	@Override
	public synchronized void run() {
		while (state < 15) {
			if (state % 3 == id) {
				for (int j = 0; j < 5; j++) {
					c++;
					System.out.format("Thread %d: %d %n", id, c);
				}
				state++;
			}
		}
	}

	public NumberPrinter(int id) {
		this.id = id;
	}

	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {
			new NumberPrinter(i).start();
		}
	}
}


Mojarra兄， 感谢你的思路。没想到还有这样简单的解法。
这道题是我和同学研究新浪面试题的时候发现的，我为此思考了好多个小时才想出解法一，郁闷的是我们老师几天之后讲解了这道题，他初始的解法和我的思考结果不谋而合。
至于解法二，则完全是老师的功劳，他用解法二向我们简单了介绍了一下JDK1.5中的并发访问控制。 JDK1.5的Lock和Condition结合可以做到精确唤醒waitset中的一个线程，这确实挺让人兴奋的。这几天我终于下定了决心好好学习一下java并发， 所以才把这道题发出来的。
希望以后能多与你交流。


run为什么要synchronized的呢？ 这三个线程产生竞争的。
14 楼 lyx2007825 2012-12-10  
我用Java内置的同步工具CyclicBarrier也解决了这个问题，看我的博客：
http://blog.csdn.net/lyx2007825/article/details/7767408
13 楼 lyx2007825 2012-12-09   
package net.liuyx.test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Test {
	private static int num = 0;
	private static int flag = 0;
	private static Lock lock = new ReentrantLock();
	private static Condition c1 = lock.newCondition();
	private static Condition c2 = lock.newCondition();
	private static Condition c3 = lock.newCondition();
	private static List<Condition> list = new ArrayList<Condition>();
	private static ExecutorService exec = Executors.newFixedThreadPool(4);
	static {
		list.add(c1);
		list.add(c2);
		list.add(c3);
	}

	private static void crit() {
		if (num >= 75) {
			System.exit(1);
		}
	}

	private static void print() {
		crit();
		System.out.print(Thread.currentThread());
		for (int i = 0; i < 5; i++) {
			System.out.format("%-2d ", ++num);
		}
		System.out.println();
	}

	private static void work(int i) {
			while (!Thread.interrupted()) {
				try{
					lock.lock();
					if(flag == i){
						crit();
						print();
						flag = (i + 1) % list.size();
						list.get((i+1)%list.size()).signal();
					}else{
						try {
							list.get(i%4).await();
						} catch (InterruptedException e) {
							e.printStackTrace();
						}
					}
				}finally{
					lock.unlock();
				}
			}
	}

	private static class Task implements Runnable {
		private final int i;

		public Task(int i) {
			this.i = i;
		}

		@Override
		public void run() {
			work(i);
		}

	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		for (int i = 0; i < list.size(); i++)
			exec.execute(new Task(i));
	}

}

看看这样可以不，正常输出：
[img]

[/img]
12 楼 hustguojiecheng 2012-08-24  
解法2 好像是可以 把while换成if的
11 楼 hustguojiecheng 2012-08-24  
关于问题1，考虑以下场景，即abc顺序步骤。
a、1处于synchronized，2处于waiting，3抢到锁后notifyAll结束5轮打印，剩下1和2竞争锁；
b、2抢到锁继续执行，执行后state变为3并notifyAll；
c、2在notifyAll后1还没来得及抢到锁，2就执行到了synchronized，并又再次获取了锁，由于state=3，2就waiting，这个时候处于synchronized的1抢到锁，由于state=3，1也waiting。
c也可以换为：1抢到了锁，由于state=3，1就waiting，这个时候处于synchronized的2抢到锁，由于state=3，2也waiting。
10 楼 hustguojiecheng 2012-08-24  
1. 解法一和解法二中的while (state != xx)是否可以换成if(state != xx), 为什么?
   不能。若换成if，会有以下情况：
    1、不是按照线程123依次打印的顺序；
    2、有可能线程3在线程1和线程2之前5轮打印完毕，1,2来互相竞争，如果2抢到锁，state变为3，这个时候就悲剧了，线程1和线程2永远就waiting吧！
2. 解法一的中的pn.notifyAll()是否可以换成pn.notify(), 为什么?
    不能。因为换成pn.notify()，理论上会出现某个线程永远抢不到锁导致饿死。
3. 暂时没考虑。
9 楼 coolxing 2012-04-12  
jingshuai1029 写道
兄弟，这个写法扩展性不好，如果不是三个线程而是X个线程，每次打钱y个数，直到打印到Z，你的程序怎么办.

你说的对, 扩展性确实不好, 当时写这个程序的时候没有想这么多...
不过做一个简单的重构就可以, 多谢建议
8 楼 jingshuai1029 2012-04-12  
兄弟，这个写法扩展性不好，如果不是三个线程而是X个线程，每次打钱y个数，直到打印到Z，你的程序怎么办.
7 楼 coolxing 2011-11-08  
Mojarra 写道
原描述有误！
我在运行程序的时候发现3个线程有“竞争”情况，让线程打印一轮后休眠500ms，则可以避免“竞争”。大概的思想是既然不唤醒其他的线程，自己休眠，避免在变量state，c上的竞争。

这个题目很有意思，我还研究出一些其它的解法。等把java5的那个concurrent用法一起，总结出一篇小搏客

嗯, 到时一定拜读
6 楼 Mojarra 2011-11-08  
原描述有误！
我在运行程序的时候发现3个线程有“竞争”情况，让线程打印一轮后休眠500ms，则可以避免“竞争”。大概的思想是既然不唤醒其他的线程，自己休眠，避免在变量state，c上的竞争。

这个题目很有意思，我还研究出一些其它的解法。等把java5的那个concurrent用法一起，总结出一篇小搏客
5 楼 coolxing 2011-11-07  
Mojarra 写道
搂主的第二种思路具有很高的研究价值

对于第一种方法，我这里有个思路要简单些，这个题目其实是3个运行中的线程，在某一个时刻只有一是可以打印数字的，其他2个都必须是等待状态。给每一个线程一个id，state表示打印序列，75/5/3，可以得出来共有15个打印序列，如果state%3==id,表示当前线程可以打印，否则必须等到一个可打印的序列完成才可以进行下一轮循环。那么可以在方法级上用synchronized关键字声明。虽然有线程竞争的情形出现，但不会出现思锁。 

class NumberPrinter extends Thread {
	static int c = 0;
	static int state = 0;
	private int id;

	@Override
	public synchronized void run() {
		while (state < 15) {
			if (state % 3 == id) {
				for (int j = 0; j < 5; j++) {
					c++;
					System.out.format("Thread %d: %d %n", id, c);
				}
				state++;
			}
		}
	}

	public NumberPrinter(int id) {
		this.id = id;
	}

	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {
			new NumberPrinter(i).start();
		}
	}
}


Mojarra兄， 感谢你的思路。没想到还有这样简单的解法。
这道题是我和同学研究新浪面试题的时候发现的，我为此思考了好多个小时才想出解法一，郁闷的是我们老师几天之后讲解了这道题，他初始的解法和我的思考结果不谋而合。
至于解法二，则完全是老师的功劳，他用解法二向我们简单了介绍了一下JDK1.5中的并发访问控制。 JDK1.5的Lock和Condition结合可以做到精确唤醒waitset中的一个线程，这确实挺让人兴奋的。这几天我终于下定了决心好好学习一下java并发， 所以才把这道题发出来的。
希望以后能多与你交流。
4 楼 coolxing 2011-11-07  
Mojarra 写道
ps，如果在一个打印序列完成后，让线程休眠500ms，则不会避免竞争情况

“不会避免竞争情况”这句话是不是表述有误？而且一个打印序列完成后让线程sleep 500ms有什么意义呢--sleep的时间内并不释放锁， 这只能徒增系统资源的消耗罢了。
3 楼 Mojarra 2011-11-07  
ps，如果在一个打印序列完成后，让线程休眠500ms，则不会避免竞争情况
2 楼 Mojarra 2011-11-07  
搂主的第二种思路具有很高的研究价值

对于第一种方法，我这里有个思路要简单些，这个题目其实是3个运行中的线程，在某一个时刻只有一是可以打印数字的，其他2个都必须是等待状态。给每一个线程一个id，state表示打印序列，75/5/3，可以得出来共有15个打印序列，如果state%3==id,表示当前线程可以打印，否则必须等到一个可打印的序列完成才可以进行下一轮循环。那么可以在方法级上用synchronized关键字声明。虽然有线程竞争的情形出现，但不会出现思锁。

class NumberPrinter extends Thread {
	static int c = 0;
	static int state = 0;
	private int id;

	@Override
	public synchronized void run() {
		while (state < 15) {
			if (state % 3 == id) {
				for (int j = 0; j < 5; j++) {
					c++;
					System.out.format("Thread %d: %d %n", id, c);
				}
				state++;
			}
		}
	}

	public NumberPrinter(int id) {
		this.id = id;
	}

	public static void main(String[] args) {
		for (int i = 0; i < 3; i++) {
			new NumberPrinter(i).start();
		}
	}
}

1 楼 Technoboy 2011-11-07  
1.会产生死锁
2.与对象进入waitset"队列"后被唤醒的执行点有关
3.如果用wait,notify这种方式，是根本无法达到精确的控制唤醒。
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    答复: 一道经典线程面试题的4种解法

    标题中的“答复: 一道经典线程面试题的4种解法”暗示了这是一个关于多线程编程的问题，通常在面试中出现，用于评估候选人的并发处理能力。在这个问题中，可能涉及到同步、线程安全、锁机制等关键概念。 在Java中，...

    java语言程序设计课后编程题答案答案

    10. **多线程**：Java提供了丰富的多线程支持，理解和掌握并发编程是高级Java开发者必备的技能。 在学习过程中，解决课后编程题是提高编程能力和解决问题能力的有效途径。通过“java参考答案”，学习者可以检查自己...

    JAVA编程题全集(50题及答案)

    9. **多线程**：Java提供了强大的多线程支持，了解并发编程的概念和工具（如synchronized、volatile、ThreadLocal、Lock接口等），对于优化程序性能和解决并发问题至关重要。 10. **IO与NIO**：Java的IO流和NIO...

    java开发校招面试题库（附答案与解析）java篇.pdf

    多线程知识点在面试中是重点考察项，因为它直接关联到一个开发者的系统设计能力和并发编程能力。 对于Spring框架，题库会覆盖基础的IoC和AOP原理，以及Spring MVC的工作流程和组件之间的关系。理解并掌握Spring框架...

    HDU题目java实现

    13. **多线程**：在处理并发问题时，Java的Thread类和Runnable接口是关键，理解同步和异步的概念。 14. **IO与NIO**：Java的I/O流系统以及新推出的非阻塞I/O（New IO，即NIO）。 15. **设计模式**：面向对象编程中...

    50个JAVA经典例题超好

    10. **线程编程**: 多线程是并发执行的基础，例题可能包括线程的创建、同步、通信、死锁等问题。 11. **枚举与注解**: 枚举提供了一种安全的常量表示方式，注解则可以用于元数据标注，这两个特性在现代Java编程中...

    LeetCode_Java_Solutions

    同时，它还会涉及多线程、并发编程、IO流、网络编程等进阶主题。 在数据结构方面，你将看到如何用Java实现常见的数据结构，如栈、队列、链表、树（二叉树、平衡树等）、图、哈希表等。这些数据结构在解决问题时起着...

    java常见问题 .

    - **线程同步**：利用`synchronized`关键字和显式锁机制来确保多线程访问共享资源的安全性。 - **线程间通信**：通过等待(wait)和通知(notify)机制实现线程间的协同工作。 #### 9. 内存管理 - **垃圾回收（GC）**：...

    JAVA 50题 sdau

    在Java编程领域，掌握经典问题的解法是提升技能的关键步骤。"JAVA 50题 sdau" 提供了五十个编程题目，旨在帮助开发者深化对Java语言的理解，提高解决问题的能力。这些题目分为两个部分，可能包括基础概念、数据结构...

    银海软件java面试题

    - **性能**：由于 `Hashtable` 使用了同步机制，所以在多线程环境下，它的性能比 `HashMap` 差。 - **初始容量和负载因子**：`HashMap` 提供了更灵活的初始容量和负载因子设置，而 `Hashtable` 的初始容量固定为 11...

    06-10年软件设计师考试真题

    2. **编程语言与数据结构**：软件设计师需要熟练掌握至少一种或多种编程语言，如Java、C++或Python。同时，对数据结构的理解至关重要，包括数组、链表、树、图、栈、队列等，它们是解决复杂问题的基础工具。 3. **...

    Java-Practice-Problems:回购解决bat和LeetCode Java问题的解决方案

    - **基础**：熟悉Java语法、异常处理、集合框架、多线程、IO流等基础内容。 - **高级**：了解JVM内存模型、垃圾回收机制、并发编程、设计模式、Spring框架等。 - **算法**：熟练运用各种算法和数据结构，如排序、...

    科大讯飞笔试题汇总

    ### 科大讯飞笔试题知识点汇总 #### 一、STL库组成部分 - **算法**：这部分提供了各种通用算法，比如排序、查找等。... - **并发容器**：使用专门为多线程设计的容器，比如`ConcurrentHashMap`等。

    蓝桥杯大赛试题

    6. **多线程**：在并发编程中，理解线程的概念、同步机制（如synchronized关键字、wait/notify）以及线程池的使用，对于提高程序性能和稳定性十分重要。 7. **算法与数据结构**：蓝桥杯大赛特别注重算法，如排序...

    用java解决TSP问题

    - **多线程**：如果涉及并行计算，Java的并发库如`ExecutorService`和`Future`接口是必不可少的。 - **异常处理**：良好的异常处理可以提高程序的健壮性。 7. **测试与调试**：编写完成后，使用**单元测试**验证...

    数据结构算法【啊哈、java数据算法与结构等】

    此外，Java并发库（`java.util.concurrent`）提供了高效线程同步和并发数据结构，如`ConcurrentHashMap`。 这个资料包中的"java算法书"很可能包含了许多经典的算法实例和详细解释，帮助读者深入理解数据结构和算法...

    Java1000道互联网大厂面试题目以及解析

    再者，多线程和并发编程是Java面试的热点。你需要了解线程的创建与管理，同步机制（如synchronized、volatile、Lock接口），以及并发工具类（如Semaphore、CountDownLatch、CyclicBarrier）。面试官可能会让你设计一...

    神州数码笔试题，神州数码笔试题

    以上就是题目中涉及的主要知识点，包括字符串处理、SQL、排列组合、逻辑推理、时间管理、多线程编程、TCP协议、网络编程中的并发处理和字节序转换等内容。理解和掌握这些知识点对于从事IT行业，尤其是软件开发和系统...

    《剑指offer》Java版代码

    9. **多线程**：Java提供强大的并发支持，理解和掌握线程同步、死锁等概念，对于大型系统设计至关重要。 10. **IO流**：在处理文件输入输出时，IO流的使用是必不可少的。 通过对《剑指Offer》Java版代码的研读和...

Magicbox
Global site tag (gtag.js) - Google Analytics