现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？
目的是检测你对”join”方法是否熟悉。这个多线程问题比较简单，可以用join方法实现。
核心：
thread.Join把指定的线程加入到当前线程，可以将两个交替执行的线程合并为顺序执行的线程。
比如在线程B中调用了线程A的Join()方法，直到线程A执行完毕后，才会继续执行线程B。
想要更深入了解，建议看一下join的源码，也很简单的，使用wait方法实现的。
t.join(); //调用join方法，等待线程t执行完毕
t.join(1000); //等待 t 线程，等待时间是1000毫秒。
public static voidmain(String[] args) {
method01();
method02();
}/*** 第一种实现方式，顺序写死在线程代码的内部了，有时候不方便*/
private static voidmethod01() {
Thread t1= new Thread(newRunnable() {
@Overridepublic voidrun() {
System.out.println("t1 is finished");
}
});
Thread t2= new Thread(newRunnable() {
@Overridepublic voidrun() {try{
t1.join();
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println("t2 is finished");
}
});
Thread t3= new Thread(newRunnable() {
@Overridepublic voidrun() {try{
t2.join();
}catch(InterruptedException e) {
e.printStackTrace();
}
System.out.println("t3 is finished");
}
});
t3.start();
t2.start();
t1.start();
}/*** 第二种实现方式，线程执行顺序可以在方法中调换*/
private static voidmethod02(){
Runnable runnable= newRunnable() {
@Overridepublic voidrun() {
System.out.println(Thread.currentThread().getName()+ "执行完成");
}
};
Thread t1= new Thread(runnable, "t1");
Thread t2= new Thread(runnable, "t2");
Thread t3= new Thread(runnable, "t3");try{
t1.start();
t1.join();
t2.start();
t2.join();
t3.start();
t3.join();
}catch(InterruptedException e) {
e.printStackTrace();
}
}
在Java中Lock接口比synchronized块的优势是什么？你需要实现一个高效的缓存，它允许多个用户读，但只允许一个用户写，以此来保持它的完整性，你会怎样去实现它？
Lock读写锁机制可以实现！
在Java中Lock接口比synchronized块的优势是什么？
Lock接口最大的优势是为读和写分别提供了锁。
importjava.text.SimpleDateFormat;importjava.util.Date;importjava.util.Random;importjava.util.concurrent.locks.ReadWriteLock;importjava.util.concurrent.locks.ReentrantReadWriteLock;public classJoinTest2 {public static voidmain(String[] args) {final TheData theData = newTheData();for(int i=0;i<4;i++){new Thread(newRunnable() {
@Overridepublic voidrun() {
theData.get();
}
}).start();
}for(int i=0;i<4;i++){new Thread(newRunnable() {
@Overridepublic voidrun() {
theData.put(new Random().nextInt(1000));
}
}).start();
}
}
}classTheData{private Integer data = 0;private ReadWriteLock rwLock = newReentrantReadWriteLock();
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");public voidget(){
rwLock.readLock().lock();//读锁开启，读进程均可进入
try{//用try finally来防止因异常而造成的死锁
System.out.println(Thread.currentThread().getName()+"read lock is ready.."+sdf.format(newDate()));
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+"read data is"+data);
}catch(InterruptedException e) {
e.printStackTrace();
}finally{
rwLock.readLock().unlock();//读锁解锁
}
}public voidput(Integer data){
rwLock.writeLock().lock();//写锁开启，这时只有一个写线程进入
try{//用try finally来防止因异常而造成的死锁
System.out.println(Thread.currentThread().getName()+"write lock is ready.."+sdf.format(newDate()));
Thread.sleep(1000);this.data =data;
System.out.println(Thread.currentThread().getName()+"write data is"+data);
}catch(InterruptedException e) {
e.printStackTrace();
}finally{
rwLock.writeLock().unlock();//写锁解锁
}
}
}
在java中wait和sleep方法的不同？
通常会在电话面试中经常被问到的Java线程面试问题。
最大的不同是在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。
此处我想理一下Java多线程的基础知识：
- Java的多线程锁是挂在对象上的，并不是在方法上的。即每个对象都有一个锁，当遇到类似synchronized的同步需要时，就会监视(monitor)每个想使用本对象的线程按照一定的规则来访问，规则也就是在同一时间内只能有一个线程能访问此对象。
- Java中获取锁的单位是线程。当线程A获取了对象B的锁，也就是对象B的持有标记上写的是线程A的唯一标识，在需要同步的情况下的话，只有线程A能访问对象B。
- Thread常用方法有：start/stop/yield/sleep/interrupt/join等，他们是线程级别的方法，所以并不会太关心锁的具体逻辑。
- Object的线程有关方法是：wait/wait(事件参数)/notify/notifyAll，他们是对象的方法，所以使用的时候就有点憋屈了，必须当前线程获取了本对象的锁才能使用，否则会报异常。但他们能更细粒度的控制锁，可以释放锁。
