Java多线程并发笔记

1. sleep和yild和wiat的区别
   • sleep会让当前线程进入阻塞状态，其他的线程会得到执行机会，但是并不会释放对象锁，也就说其他的线程想要访问sleep线程的同步方法还是不行。
   • yild暂停的线程进入runable状态，有可能又回立马被执行，而且yild只会让同等优先级或者高优先级的线程执行，低优先级的线程没有机会得到执行。
   • wait，notify，notifyall必须全部在同步代码块中使用。当前线程调用wait方法会释放线程锁进入该对象的等待池中，当有线程调用该对象的notify或着notifyall方法是，等待池中的线程会进入该对象的锁池中。当获得对象锁的线程执行完释放了锁时，在当前对象的锁池中的线程开始竞争对象锁。拿到锁的线程继续执行，没有拿到锁的线程继续在锁池中等待。
2. 死锁问题

	public class DeadLock {
	    //水壶
	    private static Object object1 = new Object();
	    //水杯
	    private static Object object2 = new Object();

	    public static void main(String[] args) {
	        Thread a = new Thread(new TaskA());
	        a.start();
	        Thread b = new Thread(new TaskB());
	        b.start();

	    }

	    static class TaskA implements Runnable {
	        @Override
	        public void run() {
	            while (true) {
	                synchronized (object1){
	                    System.out.println("task a get lock object1");
	                    try {
	                        Thread.sleep(3000);
	                    } catch (InterruptedException e) {
	                        e.printStackTrace();
	                    }
	                    synchronized (object2){
	                        try {
	                            System.out.println("task a get lock object2");
	                            Thread.sleep(2000);
	                        } catch (InterruptedException e) {
	                            e.printStackTrace();
	                        }
	                    }
	                }
	            }
	        }
	    }

	    static class TaskB implements Runnable {
	        @Override
	        public void run() {
	            while (true) {
	                synchronized (object2){
	                    System.out.println("task b get lock object2");
	                    try {
	                        Thread.sleep(3000);
	                    } catch (InterruptedException e) {
	                        e.printStackTrace();
	                    }
	                    synchronized (object1){
	                        try {
	                            System.out.println("task b get lock object1");
	                            Thread.sleep(2000);
	                        } catch (InterruptedException e) {
	                            e.printStackTrace();
	                        }
	                    }
	                }
	            }
	        }
	    }
	}

3. volatile关键字 volatile用来保证多线程环境下，变量读操作总是能够获取最新的值。但是volatile并不能保证原子性。volatile一个经典实用场景就是double check方式获取单例

	class Singleton{
	    private volatile static Singleton instance = null;
	     
	    private Singleton() {
	         
	    }
	     
	    public static Singleton getInstance() {
	        if(instance==null) {
	            synchronized (Singleton.class) {
	                if(instance==null)
	                    instance = new Singleton();
	            }
	        }
	        return instance;
	    }
	}

4. lock机制和synchronized
   • Lock是一个接口，而synchronized是Java中的关键字，synchronized是内置的语言实现； synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁；
   • Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；
   • 通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。
   • Lock可以提高多个线程进行读操作的效率。（可以通过readwritelock实现读写分离）
   • 性能上来说，在资源竞争不激烈的情形下，Lock性能稍微比synchronized差点（编译程序通常会尽可能的进行优化synchronized）。但是当同步非常激烈的时候，synchronized的性能一下子能下降好几十倍。而ReentrantLock确还能维持常态。

转载于:https://my.oschina.net/simaben/blog/3014972