Java自整理面试题之——线程相关

1. 说一下Java中锁的概念
2. 创建线程池有什么好处？
3. 如何使线程有序的进行？

//一、使用Thread.join()方法来确定该线程执行完毕
public class Test {
    public static void main(String[] args) {
        final Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"开始执行");
        },"线程1");

        final Thread t2 = new Thread(() -> {
            try {
                t1.join();
                System.out.println(Thread.currentThread().getName()+"开始执行");
            }catch (InterruptedException e){
                System.out.println(e);
            }
        },"线程2");

        final Thread t3 = new Thread(() -> {
            try {
                t2.join();
                System.out.println(Thread.currentThread().getName()+"开始执行");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"线程3");

        t1.start();
        t2.start();
        t3.start();
    }
}
//二、使用线程池的队列来执行任务
public class Test {
    public static void main(String[] args) {

        final Thread t1 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"开始执行");
        },"线程1");

        final Thread t2 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"开始执行");
        },"线程2");

        final Thread t3 = new Thread(() -> {
            System.out.println(Thread.currentThread().getName()+"开始执行");
        },"线程3");

        ExecutorService exec = Executors.newSingleThreadExecutor();
        exec.submit(t1);
        exec.submit(t2);
        exec.submit(t3);
    }
}
//	三、使用同步锁(sync或Lock)
public class Test {
    public void Method(Object o){
        synchronized (o){
            try {
                System.out.println(Thread.currentThread().getName()+"开始时间："+System.currentTimeMillis());
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName()+"结束时间："+System.currentTimeMillis());

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        Object o1 = new Object();
        Test t = new Test();
        new Thread(() -> {
            t.Method(o1);
        }).start();

        new Thread(() -> {
            t.Method(o1);
        }).start();
    }
}
*注意对象锁必须作用同一个对象！ 

5. synchronized的用法有哪几种？
   一、修饰代码块，作用对象是调用这段代码块的对象
   synchronized(this/obj){
   /
   代码块（run方法或其他）
   /
   }
   二、修饰方法，作用范围是整个方法，作用的对象是调用这个方法的对象
   public synchronized void method(){
   //todo
   } 或
   public void method(){
   synchronized(this){
   //todo
   }
   }
   三、修饰一个静态方法，作用对象是这个类的所有对象
   public synchronized static void method(){ //todo }
   (*注意区分和修饰普通方法的区别)
   四、修饰一个类，作用对象是这个类的所有对象
   class className{
   public void method(){
   synchronized(className.class){ //todo }
   }
   }
   总结：无论synchronized关键字加在方法还是对象上 如果它的作用对象是非静态的，则它 取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对象，该类所有的对象同一把锁。
6. sleep() 和 wait() 的区别
7. 多线程有几种实现方式
8. 后台程序异步有几种实现方法
9. 有三个线程A、B、C，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，要求交替打印ABC十次

public class ThreadTest implements Runnable {

    private String name;
    private Object prev;
    private Object self;

    public ThreadTest(String name,Object prev,Object self){
        this.name = name;
        this.prev = prev;
        this.self = self;
    }

    @Override
    public void run() {
        int count = 10;
        while (count>0){
            synchronized (prev){
                synchronized (self){
                    System.out.println(name);
                    count--;

                    self.notify();
                }
                try {
                    prev.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}
public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        Object c = new Object();
        ThreadTest ta = new ThreadTest("A",c,a);
        ThreadTest tb = new ThreadTest("B",a,b);
        ThreadTest tc = new ThreadTest("C",b,c);


        try {
            new Thread(ta).start();
            Thread.sleep(100); //确保顺序A、B、C执行
            new Thread(tb).start();
            Thread.sleep(100);
            new Thread(tc).start();
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }