`

考察wait notify 交互的一道面试题目

循环打印多线程waitnotify 
阅读更多
前两天去面试 有一道题目，答的很不满意。先是理解错题意，后是感觉做不出索性交卷，在等待面试中想清楚了这道题的思路。
当时那会真是糊涂，最初想的是考察join的含义， 题目写了一半感觉不对头，后来考虑 java 5 提供的各种多线程控制组件（好久不用，不熟悉了啊），也没想出办法，其实用最基本的wait notify 就能实现了，真真不该早叫卷。。。

join:是等待另外一个线程的完全结束。现在需要循环打印，显然是不行的。

题目想考察的是线程间的交互控制，即 wait notify 来实现的交互

题目：启动三个线程，分别打印A B C，现在写一个程序 循环打印ABCABCABC.... 



package com.dajie.position.thread;

/**
 * 输出A字符任务
 * @author xinchun.wang
 *
 */
class TaskA implements Runnable {
    private Object lockC;
    private Object lockA;

    public TaskA(Object lockC,Object lockA) {
	this.lockC = lockC;
	this.lockA = lockA;
    }

    @Override
    public void run() {
	boolean falg = true;
	while (true) {
	    synchronized (lockC) {
		try {
		    if (!falg) {
			lockC.wait();
		    }
		} catch (InterruptedException e) {
		    e.printStackTrace();
		    return;
		}
		falg = false;
		System.out.println("A");
	    }
	    
	    try {
		    Thread.sleep(1000);
		} catch (InterruptedException e) {
		    // TODO Auto-generated catch block
		    e.printStackTrace();
		}
	    
	   synchronized(lockA){
	       lockA.notify();
	   }
	}
    }

}

/**
 * 输出B字符串任务
 * @author xinchun.wang
 *
 */
class TaskB implements Runnable {
    private Object lockA;
    private Object lockB;
    public TaskB(Object lockA,Object lockB) {
	this.lockA = lockA;
	this.lockB = lockB;
    }

    @Override
    public void run() {
	while (true) {
	    synchronized (lockA) {
		try {
		    lockA.wait();
		} catch (InterruptedException e) {
		    e.printStackTrace();
		    return;
		}
		System.out.println("B");
	    }
	    
	    try {
		    Thread.sleep(1000);
		} catch (InterruptedException e) {
		    // TODO Auto-generated catch block
		    e.printStackTrace();
		}
	    
	    synchronized (lockB) {
		lockB.notify();
	    }
	}
    }

}

/**
 * 输出C字符串任务
 * @author xinchun.wang
 *
 */
class TaskC implements Runnable {
    private Object lockB;
    private Object lockC;
    public TaskC(Object lockB,Object lockC) {
	this.lockB = lockB;
	this.lockC = lockC;
    }

    @Override
    public void run() {
	while (true) {
	    synchronized (lockB) {
		try {
		    lockB.wait();
		} catch (InterruptedException e) {
		    e.printStackTrace();
		    return;
		}
		System.out.println("C");
	    }
	    
	    try {
		    Thread.sleep(1000);
		} catch (InterruptedException e) {
		    // TODO Auto-generated catch block
		    e.printStackTrace();
		}
	    
	    synchronized (lockC) {
		lockC.notify();
	    }
	}

    }

}

/**
 * 测试例子
 * @author xinchun.wang
 *
 */
public class PrintData {
    public static void main(String[] args) {
	Object lockA = new Object();
	Object lockB = new Object();
	Object lockC = new Object();

	Thread tA = new Thread(new TaskA(lockC,lockA));
	Thread tB = new Thread(new TaskB(lockA,lockB));
	Thread tC = new Thread(new TaskC(lockB,lockC));
	tA.start();
	tB.start();
	tC.start();

    }
}
0
顶
1
踩
分享到：
| java io流类的功能概述
评论
17 楼 daojin 2013-05-11  
heirenhua 写道
我觉得比较好的是CSDN上的某大牛给的答案。

http://bbs.csdn.net/topics/360111428?page=1#post-394423315

45楼

呵呵，里面有个答案挺不错。
16 楼 heirenhua 2013-05-08  
我觉得比较好的是CSDN上的某大牛给的答案。

http://bbs.csdn.net/topics/360111428?page=1#post-394423315

45楼
15 楼 zjumty 2013-05-05  
daojin 写道

按道理，这个锁应该是动态的，一开始是不需要陷入内核的，如果等待时间过长，就陷入内核。这样效率才高。


你说的没错， 我看的是openjdk 7的代码。 JVM并不是会直接使用WaitForSingleObject之类的调用陷入内核模式。而是会先Spin一定的周期，并且还有很多判断，只有在"万不得已"的情况下才会陷入内核模式。 可能DVM是面向移动设备设计的，所以在并发上更加重视效率吧。
14 楼 daojin 2013-05-05  
你好，我刚才查了一下google的代码，在google安卓的源代码中没有找到semophore的影子。就连消息队列都是用wait，notify来写的。google工程师不可能不知道semophore的方便性的，但是还是没有使用它。我觉得最重要的原因就是效率问题，semophore的实现没有进行优化。不同的java虚拟机，不同的操作系统平台之间差异比较大。

效率问题是拿不陷入内核消耗的CPU时间片和陷入内核消耗的时间片进行对比。

按道理，这个锁应该是动态的，一开始是不需要陷入内核的，如果等待时间过长，就陷入内核。这样效率才高。

另外一个问题是，JVM是不是按照上面说的实现的？

目前我从网上得到的信息http://www.blogjava.net/xiaohuzi2008/archive/2012/07/17/383344.html
这篇文章。确实是这样的。但是我没有源代码，也不知道怎么找。你熟悉的话帮忙找一下在什么地方，共同学习进步。

另外，安卓虚拟机DVM中，semophore的实现也不是动态的，并且是不需要陷入内核的。直接用汇编来写的。

     

    int32_t prev;
    __asm__ __volatile__ ("lock; cmpxchgl %1, %2"
                          : "=a" (prev)
                          : "q" (new_value), "m" (*ptr), "0" (old_value)
                          : "memory");
    return prev != old_value;



13 楼 daojin 2013-05-05  
zjumty 写道
daojin 写道

不过简洁的不一定是最好的。如果考虑效率问题，还是java的synchronized，wait，notify机制效率高。因为信号量需要陷入内核。而wait的实现时，可以不需要陷入内核。
效率提高十倍以上。


用synchronized，wait，notify确实可以实现出比Semaphore更高效的方式。
但是“信号量需要陷入内核。而wait的实现时，可以不需要陷入内核”不是很理解。

是乎synchronized方式和Semaphore(LockSupport.park)，到了jvm那一层都是ObjectMonitor.cpp这个类实现的，而这个类的同步方法里，经过判断确实需要将线程挂起时，都是调用_ParkEvent->park ()方法， 这个方法在各个OS上实现略有不同， 在WIndows上是CreateEvent和WaitForSingleObjec()，在Linux上是ptread的pthread_cond_wait。

我对操作系统不是十分了解，使用上述的机制难道不是要切换到内核模式吗？

求解答。


陷入内核的话很明显的效率低下。你说的那些都会陷入内核。是重量级的锁机制。你一定是找错代码了。或者你的虚拟机版本在1.6以下。1.6以上不应该是这个机制。
12 楼 zjumty 2013-05-05  
daojin 写道

不过简洁的不一定是最好的。如果考虑效率问题，还是java的synchronized，wait，notify机制效率高。因为信号量需要陷入内核。而wait的实现时，可以不需要陷入内核。
效率提高十倍以上。


用synchronized，wait，notify确实可以实现出比Semaphore更高效的方式。
但是“信号量需要陷入内核。而wait的实现时，可以不需要陷入内核”不是很理解。

是乎synchronized方式和Semaphore(LockSupport.park)，到了jvm那一层都是ObjectMonitor.cpp这个类实现的，而这个类的同步方法里，经过判断确实需要将线程挂起时，都是调用_ParkEvent->park ()方法， 这个方法在各个OS上实现略有不同， 在WIndows上是CreateEvent和WaitForSingleObjec()，在Linux上是ptread的pthread_cond_wait。

我对操作系统不是十分了解，使用上述的机制难道不是要切换到内核模式吗？

求解答。

11 楼 静湖孤子 2013-05-05  
package org.codinglife.printABC2;

public class PrintABC implements Runnable {

public static void main(String[] args) throws InterruptedException {
new Thread(new PrintABC()).start();
}

@Override
public void run() {
Thread printA = new RunPrint("A");
Thread printB = new RunPrint("B");
Thread printC = new RunPrint("C");

synchronized(printA) {
synchronized (printB) {
synchronized (printC) {
System.out.println("Main Dispatcher");
printA.start();
printB.start();
printC.start();

while(true) {
try {
printA.notify();
printA.wait();

printB.notify();
printB.wait();

printC.notify();
printC.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}
}

class RunPrint extends Thread {
private String printStr;

public RunPrint(String printStr) {
this.printStr = printStr;
}

@Override
public void run() {
while(true) {
synchronized (this) {
System.out.println(printStr);
this.notify();
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}

花时间写了一个, 练练手.
10 楼 daojin 2013-05-04  
sunlujing 写道
zjumty 写道
如果可以用Java5以后的Semaphore实现起来比较简单

public class ThreadSync {
    static class ConditionThread extends Thread {
        ConditionThread(Semaphore preCond, Semaphore postCond, String text) {
            this.preCond = preCond;
            this.postCond = postCond;
            this.text = text;
        }

        private Semaphore preCond;
        private Semaphore postCond;
        private String text;


        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    preCond.acquire();
                    System.out.print(text);
                    postCond.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphoreA = new Semaphore(0);
        Semaphore semaphoreB = new Semaphore(0);
        Semaphore semaphoreC = new Semaphore(1);

        Thread threadA = new ConditionThread(semaphoreC, semaphoreA, "A");
        Thread threadB = new ConditionThread(semaphoreA, semaphoreB, "B");
        Thread threadC = new ConditionThread(semaphoreB, semaphoreC, "C");

        threadA.start();
        threadB.start();
        threadC.start();

        threadA.join();
        threadB.join();
        threadC.join();
    }
}

这个方法比较简洁

不过简洁的不一定是最好的。如果考虑效率问题，还是java的synchronized，wait，notify机制效率高。因为信号量需要陷入内核。而wait的实现时，可以不需要陷入内核。
效率提高十倍以上。
9 楼 sunlujing 2013-05-04  
zjumty 写道
如果可以用Java5以后的Semaphore实现起来比较简单

public class ThreadSync {
    static class ConditionThread extends Thread {
        ConditionThread(Semaphore preCond, Semaphore postCond, String text) {
            this.preCond = preCond;
            this.postCond = postCond;
            this.text = text;
        }

        private Semaphore preCond;
        private Semaphore postCond;
        private String text;


        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    preCond.acquire();
                    System.out.print(text);
                    postCond.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphoreA = new Semaphore(0);
        Semaphore semaphoreB = new Semaphore(0);
        Semaphore semaphoreC = new Semaphore(1);

        Thread threadA = new ConditionThread(semaphoreC, semaphoreA, "A");
        Thread threadB = new ConditionThread(semaphoreA, semaphoreB, "B");
        Thread threadC = new ConditionThread(semaphoreB, semaphoreC, "C");

        threadA.start();
        threadB.start();
        threadC.start();

        threadA.join();
        threadB.join();
        threadC.join();
    }
}

这个方法比较简洁
8 楼 daojin 2013-05-04  
zjumty 写道
如果可以用Java5以后的Semaphore实现起来比较简单

public class ThreadSync {
    static class ConditionThread extends Thread {
        ConditionThread(Semaphore preCond, Semaphore postCond, String text) {
            this.preCond = preCond;
            this.postCond = postCond;
            this.text = text;
        }

        private Semaphore preCond;
        private Semaphore postCond;
        private String text;


        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    preCond.acquire();
                    System.out.print(text);
                    postCond.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphoreA = new Semaphore(0);
        Semaphore semaphoreB = new Semaphore(0);
        Semaphore semaphoreC = new Semaphore(1);

        Thread threadA = new ConditionThread(semaphoreC, semaphoreA, "A");
        Thread threadB = new ConditionThread(semaphoreA, semaphoreB, "B");
        Thread threadC = new ConditionThread(semaphoreB, semaphoreC, "C");

        threadA.start();
        threadB.start();
        threadC.start();

        threadA.join();
        threadB.join();
        threadC.join();
    }
}

这个写得不错。
信号量对资源访问的控制，有一个逻辑隐含在里面，而wait却没有。这就是信号量的强项。
7 楼 王新春 2013-05-04  
daojin 写道
 

同学，多线程很难啊，不过你的题目非常好。让我练习了一下多线程。谢谢。

不过，看你的基础不牢啊，再好好想想！多线程真的很难，不是一般的。程序搞了四五年了，现在才略知一二。

嗯，我考虑确实不周，其实题目提醒：不准用sleep ，所以我的答案是有问题的，谢谢提醒。不过多线程没有太难，只要你理解了。但是我们可能考虑不周。加油小伙。
6 楼 zjumty 2013-05-04  
如果可以用Java5以后的Semaphore实现起来比较简单

public class ThreadSync {
    static class ConditionThread extends Thread {
        ConditionThread(Semaphore preCond, Semaphore postCond, String text) {
            this.preCond = preCond;
            this.postCond = postCond;
            this.text = text;
        }

        private Semaphore preCond;
        private Semaphore postCond;
        private String text;


        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    preCond.acquire();
                    System.out.print(text);
                    postCond.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphoreA = new Semaphore(0);
        Semaphore semaphoreB = new Semaphore(0);
        Semaphore semaphoreC = new Semaphore(1);

        Thread threadA = new ConditionThread(semaphoreC, semaphoreA, "A");
        Thread threadB = new ConditionThread(semaphoreA, semaphoreB, "B");
        Thread threadC = new ConditionThread(semaphoreB, semaphoreC, "C");

        threadA.start();
        threadB.start();
        threadC.start();

        threadA.join();
        threadB.join();
        threadC.join();
    }
}
5 楼 daojin 2013-05-03  
 

同学，多线程很难啊，不过你的题目非常好。让我练习了一下多线程。谢谢。

不过，看你的基础不牢啊，再好好想想！多线程真的很难，不是一般的。程序搞了四五年了，现在才略知一二。
4 楼 daojin 2013-05-03   


package MyTesting;

/**
 * 输出A字符任务
 * @author xinchun.wang
 *
 */
class TaskA implements Runnable {
	
    private Object lockC;
    private Object lockA;

    public TaskA(Object lockC,Object lockA) {
	this.lockC = lockC;
	this.lockA = lockA;
    }

    @Override
    public void run() {
	
	while (true) {
	    synchronized (lockC) {
	    	try {
	    		while (!PrintData.mCHavPrint) {
	    			lockC.wait();
	    		}
			} catch (InterruptedException e) {
				e.printStackTrace();
				return;
			}
	    	 PrintData.mCHavPrint = false;
	     }
	    
	     System.out.println("A");
	     
	     synchronized(lockA){
	    	 PrintData.mAHavPrint = true;
	         lockA.notify();
	      }
	    }
    }

}

/**
 * 输出B字符串任务
 * @author xinchun.wang
 *
 */
class TaskB implements Runnable {
    private Object lockA;
    private Object lockB;
    public TaskB(Object lockA,Object lockB) {
	this.lockA = lockA;
	this.lockB = lockB;
    }

    @Override
    public void run() {
	while (true) {
		
	    synchronized (lockA) {
			try {
	    		while (!PrintData.mAHavPrint) {
	    			lockA.wait();
	    		}
			} catch (InterruptedException e) {
				e.printStackTrace();
				return;
			}
			  PrintData.mAHavPrint = false;
		
	    }
	  
	    
	    System.out.println("B");
	    synchronized (lockB) {
	    	PrintData.mBHavPrint= true;
	    	lockB.notify();
	    }
	}
    }

}

/**
 * 输出C字符串任务
 * @author xinchun.wang
 *
 */
class TaskC implements Runnable {
    private Object lockB;
    private Object lockC;
    public TaskC(Object lockB,Object lockC) {
	this.lockB = lockB;
	this.lockC = lockC;
    }

    @Override
    public void run() {
	while (true) {
	    synchronized (lockB) {
	    	try {
	    		while (!PrintData.mBHavPrint) {
	    			lockB.wait();
	    		}
			} catch (InterruptedException e) {
				e.printStackTrace();
				return;
			}
	    	  PrintData.mBHavPrint = false;
	    }
	    
	  
	    System.out.println("C");
	    
	    synchronized (lockC) {
	    	PrintData.mCHavPrint = true;
	    	lockC.notify();
	    }
	}

    }

}

/**
 * 测试例子
 * @author xinchun.wang
 *
 */
public class PrintData {
	 public static boolean mCHavPrint = true;
	 public static boolean mAHavPrint = false;
	 public static boolean mBHavPrint = false;
    public static void main(String[] args) {
    
   
    
	Object lockA = new Object();
	Object lockB = new Object();
	Object lockC = new Object();

	Thread tA = new Thread(new TaskA(lockC,lockA));
	Thread tB = new Thread(new TaskB(lockA,lockB));
	Thread tC = new Thread(new TaskC(lockB,lockC));
	tA.start();
	tB.start();
	tC.start();

    }
}
3 楼 daojin 2013-05-03  
有问题啊。你这个a如果一开始就notify过了。b就永远wait不到。
2 楼 王新春 2013-05-03   
           synchronized (self) {  
               synchronized (next) {  
                    System.out.println(name);  
                  count--;  
                    next.notify();  
              }  
               try {  
                   self.wait();  
              } catch (InterruptedException e) {  
                   e.printStackTrace();  
               }  
            }


楼上也是正解，并且更简洁，我只是给个思路。我刚才查了下，这个题目网上很多答案，看样子以后还得多看看社区的题目啊
1 楼 terry21 2013-05-03   
public class Printer implements Runnable {
	private String name;
	private Object self;
	private Object next;

	private Printer(String name, Object self, Object next) {
		this.name = name;
		this.self = self;
		this.next = next;
	}

	public void run() {
		int count = 100;
		while (count > 0) {
			System.out.println(count);
			synchronized (self) {
				synchronized (next) {
					System.out.println(name);
					count--;
					next.notify();
				}
				try {
					self.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
		}
	}

	public static void main(String[] args) throws Exception {
		Object a = new Object();
		Object b = new Object();
		Object c = new Object();

		Printer pa = new Printer("A", a, b);
		Printer pb = new Printer("B", b, c);
		Printer pc = new Printer("C", c, a);

		new Thread(pa).start();
		Thread.sleep(10);
		new Thread(pb).start();
		Thread.sleep(10);
		new Thread(pc).start();
		Thread.sleep(10);
	}
}
发表评论

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

相关推荐

    平安公司JAVA面试题目

    【Java面试核心知识点详解】 在Java面试中，无论是对于初学者还是有经验的开发者，深入理解...平安公司作为知名公司，其面试题目通常会结合实际工作场景，不仅测试技术知识，也会考察候选人的逻辑思维和问题解决能力。

    java面试和笔试题目

    5. **多线程**：包括线程的创建方式（Thread类和Runnable接口）、同步机制（synchronized关键字、锁对象、volatile关键字、wait/notify机制）、死锁、线程池（ExecutorService）等。 6. **IO流**：了解输入输出流的...

    java面试总结以及1000+道面试题

    此外，Java内存模型（JMM）以及线程间的通信方式（如wait/notify、join、CountDownLatch等）也常常是考察的重点。 对于高级主题，如设计模式，面试者应能熟练应用单例、工厂、观察者、装饰器、代理等常见设计模式，...

    Java面试题全集（上）（中）（下）合集

    常见面试题目可能涉及排序算法、查找算法、图论、动态规划等。 通过阅读《Java面试题全集》的上下册，可以系统地复习以上各个方面的知识，提高Java面试的成功率。同时，结合实际项目经验和案例分析，将使你在面试中...

    全国各大城市公司JAVA 数据库面试题

    然而，C语言作为基础编程语言，其面试题目可能涵盖指针、内存管理、函数、结构体、预处理器等方面。 1. **指针**：理解指针的运算，指针与数组的关系，指针与函数的交互。 2. **内存管理**：栈与堆的区别，动态...

    张孝祥正在整理Java就业面试题大全

    理解线程同步和互斥，掌握synchronized关键字、wait/notify机制、Lock接口及并发工具类，对于处理多线程问题至关重要。 5. **JVM原理**：Java虚拟机是Java程序运行的平台，了解JVM内存模型、垃圾收集机制、类加载...

    javaMianshiti.rar_IT 面试_试题_面试 java_面试题

    7. **多线程**：掌握线程的创建方式（Thread类和Runnable接口），同步机制（synchronized、wait/notify、Lock接口）。 8. **反射机制**：能够动态加载类、创建对象、访问私有成员。 9. **垃圾回收机制**：理解JVM...

    Java面试题

    面试中可能涉及线程同步与通信（synchronized、wait()、notify()、join()、volatile关键字），死锁、活锁、阻塞队列等高级主题。 5. **异常处理**：理解何时使用try-catch-finally，如何定义和抛出自定义异常，以及...

    265道JAVA面试题精华汇总.zip

    8. **网络编程**：TCP/IP协议、Socket编程、服务器端与客户端的交互、HTTP协议的理解及其在Java中的应用，这些都是可能的面试题目。 9. **设计模式**：常见的23种设计模式，如单例、工厂、观察者、适配器、装饰者、...

    google百度北电华为腾讯试题及面试

    在IT行业中，面试是检验求职者技能和知识的关键环节，尤其对于知名公司如Google、百度、北电、华为和腾讯来说，他们的面试题目通常代表了业界的高标准和技术趋势。本资料包聚焦于这些公司的面试试题，主要涉及Java...

    java工作经验面试题

    面试中会关注线程同步和通信，如synchronized关键字、wait/notify机制、ReentrantLock等。 5. **JVM内存模型**：理解Java虚拟机的内存区域（堆、栈、方法区、程序计数器、本地方法栈）以及垃圾回收机制，包括新生代...

    WEB面试题汇总

    以上内容只是部分可能涵盖的面试知识点，实际的“WEB面试题汇总”PDF文件可能会更详尽，包括具体的面试题目、解答策略以及面试技巧。对于Java Web开发者来说，熟练掌握这些知识并能灵活运用，将极大地提高面试成功率...

    中国多家大公司面试题集合

    这份"中国多家大公司面试题集合"涵盖了多个大城市如北京、上海、深圳、武汉、南京和广州等知名企业的面试题目，旨在全面考察候选人在JAVA、C++、.NET以及数据库等关键领域的专业知识。下面，我们将详细探讨这些领域...

    java面试题集锦()

    5. **多线程编程**："线程编程方面.doc"可能涵盖线程的创建、同步机制（synchronized、wait()、notify()、notifyAll()）、死锁和活锁的概念、线程池的使用等。 6. **IO流与NIO**：输入/输出流的分类、操作以及非...

    unix 编程资料 面试题

    面试时可能涉及进程创建（fork）、进程间通信（管道pipe、消息队列、共享内存、套接字等）、进程同步与互斥（信号量、wait/notify机制）。 4. **IPC（Inter-Process Communication）通信机制**：Unix提供多种进程间...

    java面试笔试题大汇总 ~很全面 -

    4. **多线程**：Java提供了丰富的多线程支持，如Thread类、Runnable接口、synchronized关键字、volatile、wait/notify机制等。理解并发编程原理和线程安全问题是高并发应用设计的关键。 5. **JVM**：Java虚拟机是...

    JAVA笔试题（附答案）.zip

    这份"JAVA笔试题（附答案）.zip"压缩包显然包含了多个公司的Java笔试或面试题目，旨在帮助求职者准备相关考试或者提升自己的Java技能。下面我们将深入探讨其中涉及的一些关键知识点。 1. **基础语法**：所有Java...

    java面试题（笔试与面试）大全

    5. **多线程**：线程的创建方式（实现Runnable接口和继承Thread类），同步机制（synchronized关键字、wait/notify机制、Lock接口）。 6. **反射**：如何使用Class类进行运行时动态加载类、获取类信息、创建对象、...

    Java+最常见+216++面试题全解析.doc

    理解并发控制机制，如`synchronized`、`volatile`、`wait()`、`notify()`、`notifyAll()`以及`Lock`接口和`Condition`类等。 10. **反射** - 反射允许在运行时动态访问和修改类的信息，如创建对象、调用方法、获取...

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