1、多线程有哪几种实现方法？举个样例说明下线程的同步。

（1）Java多线程有两种实现方式：继承Thread类和实现Runnable接口，Thread就是实现了Runnable接口。

两个最简单的线程样例：

package chc.runnable;

public class ThreadTest2 {

    public static void main(String[] args) throws InterruptedException {

        Thread1 t = new Thread1();

        //t.run(); //这里也不能直接调用方法

        t.start();

        for (int i = 0; i < 100; i++) {

            System.out.println("main:"+i);

        }

    }

}

class Thread1 extends Thread{

    public void run() {

        for (int i = 0; i < 100; i++) {

            System.out.println("Thread-----:"+i);

        }

    }

}

package chc.runnable;

public class ThreadTest1 {

	public static void main(String[] args) {

		Runnable1 r =new Runnable1();

		Thread t1=new Thread(r);

		t1.start();

	}

}

class Runnable1  implements Runnable {

	public void run() {

		// TODO Auto-generated method stub

		for (int i = 1; i <= 5; i++) {

			System.out.println("实现Runnable接口的线程----->"+i);

		}

	}

}

通过上两个样例发现，当启动线程的时候并不影响主程序的继续运行。

（2）线程同步问题

使用synchronnizedkeyword

银行账户存取钱的问题：

public class ThreadTest {

	public static void main(String[] args){

		ThreadA  t1=new ThreadA();

		t1.start();

		ThreadB  t2=new ThreadB();

		t2.start();

	}

}

class ThreadA extends Thread{

	@Override

	public void run(){

		for(int i=0;i<100;i++){

			account.add();

			try {

				sleep(10);//模拟银行系统处理时间

			} catch (InterruptedException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

	}

}

class ThreadB extends Thread{

	@Override

	public void run() {

		for(int i=0;i<100;i++){

			account.remove();

			try {

				sleep(10);<span style="font-family: SimSun;">//模拟银行系统处理时间</span>

			} catch (InterruptedException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

		}

	}

}

class account {

	public static   int count=1000;

	//减去100元

	public static synchronized void remove(){

		count=count-100;

		System.out.println("减去100元,卡内剩余金额"+count);

	}

	//添加100元

	public static synchronized void add(){

		count=count+100;

		System.out.println("加上100元,卡内剩余金额"+count);

	}

}

注意：上例中将account类的add()和remove()方法都加上了statickeyword，由于这样在线程中能够直接通过类名调用到这两个方法，而不须要实例化对象。

由于synchronized同步仅仅对同一个对象中的方法有效。也就是说一个线程正在运行account的add()方法。还有一个线程是能够调用到还有一个对象的add方法的。

2、启动一个线程是用run()还是start()，调用的时候有什么差别？

当然是start()了，当调用线程的start()方法的时候，线程就会进入到就绪状态

run()方法是线程的运行入口，当线程从就绪状态进入到运行状态时首先要从run()方法開始运行。

当然，我们也是能够直接通过线程对象调用该对象的run()方法的。仅仅是这仅仅是一次普通的调用，并没有启动不论什么一个线程。

当我们调用start()方法时，是另外启动了一个线程去运行线程类的代码，并不影响主程序的运行。可是调用run()方法的时候要等待run()方法内的代码执

行完主程序才能够向下运行。举个样例:

public class ThreadDemo2 {

	public static void main(String[] args) {

		Thread5 t1=new Thread5();

		Thread6 t2=new Thread6();

		t1.run();

		t2.start();

		for(int i=0;i<100;i++){

			System.out.println("主进程运行："+i);

		}

	}

}

class Thread5 extends Thread{

	@Override

	public void run() {

		for(int i=0;i<100;i++){

			System.out.println("Thread5运行："+i);

		}

	}

}

class Thread6 extends Thread{

	@Override

	public void run() {

		for(int i=0;i<100;i++){

			System.out.println("Thread6运行："+i);

		}

	}

}

输出结果的顺序是：Thread5所有打印完后 Thread6和主程序交替打印。验证了上面的说法

3、当一个线程进入到一个对象的synchronized方法，那么其他线程能否够进入该对象的其他方法？

不一定。看情况

假设其他方法加了statickeyword，那么该方法属于类。不属于对象，不能与对象的方法保持同步（即使有synchronizedkeyword），是能进入的。

假设其他方法不带有statickeyword且带有synchronizedkeyword，那么不能进入，假设不带，则能。

再其次就看方法内部有没有wait（）方法释放锁了

4、子线程循环2次，接着主线程循环3次，接着子线程循环3次，接着主线程循环3次，如此循环5次，请写出程序代码。

public class ThreadDemo5 {

	static boolean thread_flag=false;//指示子线程循环是否结束

	static boolean main_flag=true;   //调用子线程的start方法后变为true,循环等待thread_flag为true（也就是子线程循环完）的时刻，主线程循环完又变为false;

	public static void main(String[] args) {

		for(int k=0;k<5;k++){

			Thread7 t=new Thread7();

			t.start();

			main_flag=true;

			while (main_flag) {//循环等待thread_f

				if(thread_flag){

					for(int i=0;i<3;i++){

						System.out.println("主线程第一次循环"+(i+1)+"次");

					}

					thread_flag=false;

					main_flag=false;

				}

			}

		}

	}

}

class Thread7 extends Thread {

	static boolean flag=true;//标志子线程第几次循环，当值为true的时候子线程循环2次，否则循环3次

	public void run() {

		if(flag){

			for(int i=0;i<2;i++){

				System.out.println("子线程第一次循环"+(i+1)+"次");

			}

			flag=false;

		}else{

			for(int i=0;i<3;i++){

				System.out.println("子线程第二次循环"+(i+1)+"次");

			}

			flag=true;

		}

		ThreadDemo5.thread_flag=true;

	}

}

这个题就是要注意调用子线程的start方法的时候并不能阻止主程序继续向下运行。所以我们要用变量来标记。

5、sleep()和wait()有何异同？

（1）首先一个最明显的差别是  wait是Object类的方法,而sleep()是Thread类的静态方法,谁调用了该方法谁去休眠,即使在a线程里调用了b线程的sleep方法,实际上还是a线程去休眠.

（2）比較重要的一点是sleep没有释放出锁，而wait释放了锁，是其它线程能够使用同步块资源。

sleep不出让系统资源；wait是进入线程等待池等待，出让系统资源。其它线程能够占用CPU。一般wait不会加时间限制，由于假设wait线程的执行资源不够。再出来也没用，要

等待其它线程调用notify/notifyAll唤醒等待池中的全部线程。才会进入就绪队列等待OS分配系统资源。sleep(milliseconds)能够用时间指定使它自己主动唤醒过来，假设时间不到

仅仅能调用interrupt()强行打断。

（3）使用范围：

wait，notify和notifyAll仅仅能在同步控制方法或者同步控制块里面使用。而sleep能够在不论什么地方使用 

     synchronized(x){ 

       x.notify() 

       //或者wait() 

      }

（4）sleep须要捕获异常,而wait不须要。

6、如今有T1 T2 T3三个线程。如何保证T2在T1运行完之后运行 T3在T2运行完之后运行

这题主要是考察对join()方法的使用。

当线程A其中运行了线程B.join()。那么A线程要等待B线程运行完才干够运行。

public class JoinDemo {

	public static void main(String[] args) {

		T1 t1=new T1("T1");

		T2 t2=new T2("T2");

		T3 t3=new T3("T3");

		t1.start();

		try {

			t1.join();

		} catch (InterruptedException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		t2.start();

		try {

			t2.join();

		} catch (InterruptedException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		t3.start();

	}

}

class T1 extends  Thread{

	private String name;

	public T1(String name) {

		this.name=name;

	}

	@Override

	public void run() {

		for(int i=0;i<5;i++){

			try {

				sleep(5);

			} catch (InterruptedException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

			System.out.println(this.name+"循环"+i);

		}

	}

}

class T2 extends  Thread{

	private String name;

	public T2(String name) {

		this.name=name;

	}

	@Override

	public void run() {

		for(int i=0;i<5;i++){

			try {

				sleep(5);

			} catch (InterruptedException e) {

				// TODO Auto-generated catch block

				e.printStackTrace();

			}

			System.out.println(this.name+"循环"+i);

		}

	}

}

class T3 extends  Thread{

	private String name;

	public T3(String name) {

		this.name=name;

	}

	@Override

	public void run() {

		for(int i=0;i<5;i++){

			System.out.println(this.name+"循环"+i);

		}

	}

}

7、简述synchronized和java.util.concurrent.locks.Lock的异同？

主要同样点：Lock能完毕synchronized所实现的全部功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。synchronized会自己主动释放锁。而Lock一定要求程序猿手工释放，而且必须在finally从句中释放。

Lock还有更强大的功能。比如，它的tryLock方法能够非堵塞方式去拿锁。

8、死锁问题

兴许补充……