线程相关

一、同步锁
关于同步锁，先讲讲Thread的sleep()和Object的wait()方法
sleep方法：只会让线程睡眠，并不释放锁
wait方法：会释放锁
引用 http://blog.csdn.net/luoweifu/article/details/46613015的说法
A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。
B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。
C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。
上例子

public class SyncTest {
    public static void main(String[] args) {
        new Thread(new Runnable() {         
            @Override
            public void run() {
                for(int i=0;i<10;i++) {                 
                    Singleton.getInstance();
                    System.out.println(Thread.currentThread().getName()+"获取实例"+i);
                }           
            }
        }).start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        new Thread(new Runnable() {         
            @Override
            public void run() {
                for(int i=0;i<10;i++) {
                    Singleton.print();
                }
            }
        }).start(); 
    }
}
class Singleton {
    private static Singleton instance;
    private Singleton() {       
    }   
    public static synchronized Singleton getInstance() {
        System.out.println("start"+Thread.currentThread().getName());
        try {
            Thread.sleep(5000);//此处睡眠5S，是为了清楚地知道后面的线程是否会执行
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("end"+Thread.currentThread().getName());
        return instance == null ? new Singleton():instance;
    }
    public static void print() {
        System.out.println(Thread.currentThread().getName());
    }
}

运行结果：

Thread-0调用了getInstance方法，取得了锁，并睡眠5s，此时Thread-1调用了print(）方法，也就是说，没有被锁控制的代码是不受锁限制的。
二、多线程调试
创建两个线程，通过debug 进去 ，可以看到两个线程。

此时点击Thread-1 resume 可先执行第二个线程

三、ThreadLocal（本地线程变量）
1.特点
①每个线程有独自的局部变量，互不影响
②每个线程拥有该变量的初始副本
③定义的变量由private static修饰

2.关于内存泄漏