再讲线程安全：
一、脏读
脏读：在于读字，意在在读取实例变量时，实例变量有可能被另外一个线程更改了，导致获取到的数据出现异常。
在非线程安全的情况下，如果线程A与线程B 共同使用对象实例C中的方法method，如果实例C存在实例变量，同时在method中会操作这个实例变量a，则有可能出现脏读的情况。
也就是期望值不同，读取的数据不同，因为线程A与B会同时使用实例C的方法。
例如：
private String name;
public static void main(String[] args){
Test2 test2 = new Test2();
Thread t = new Thread(new Runnable() {
@Override
public void run() {
// System.out.println(Thread.currentThread().getName());
test2.testUnsafe("a","我是A");
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
// System.out.println(Thread.currentThread().getName());
test2.testUnsafe("b","我是B");
}
});
t.start();
t2.start();
}
public void testUnsafe(String name,String param){
this.name = name;
try {
Thread.sleep(1000);
System.out.println(this.name+":"+param);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
执行结果如下：
代码中加上了sleep 为了模拟运算所需的时间。
可以看出来，大概是这样的过程：线程B在run时首先抢到了资源，并运行了实例方法，并把实例变量name修改为b，
然后继续执行，这时候线程A抢回了资源（因为不是同步的），它把实例变量那么又修改为b，这个是时候开始执行其他逻辑操作（这里用sleep模拟），
然后2个线程轮番执行最后的操作-打印。
因为这个时候实例变量name 已经变为a了， 所以线程B 出现脏读，和期望输出的 b:我是B 结果出现差异。
如果操作的是不同的对象实例（在synchronized 同步里 jvm 会创建多个锁，下面的例子控制2个实例，也就是创建了2个锁），就不会出现这个问题了，还有如果name不是实例变量，只是私有变量的话也不会出现这种情况。
修改一下看看：
public static void main(String[] args){ Thread t = new Thread(new Runnable() { @Override public void run() { Test2 test2 = new Test2(); test2.testUnsafe("a","我是A"); } }); Thread t2 = new Thread(new Runnable() { @Override public void run() { Test2 test2 = new Test2(); test2.testUnsafe("b","我是B"); } }); t.start(); t2.start(); }
输出结果：
如果想要保证使用实例变量而又不出现这种问题，怎么办，同步~ 可以使用 synchronized 方法或 synchronized代码块。
例如：
public synchronized void testUnsafe(String name,String param){
this.name = name;
try {
Thread.sleep(1000);
System.out.println(this.name+":"+param);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
输出结果：
关于synchronized 想看的可以下看之前的随笔（《JAVA 多线程（1）》）。
这里我想记录一下类与对象和实例的个人理解（）：
Class 是类，编写时候我们称为类，编译好的class我们可以称为class对象，或者说类对象，由类对象new出来的是实例或者说叫对象实例也就是instance。
它们分时期，分关系。类是抽象的概念，对象为具体的事物，人是类，张三是人，张三是人这个类具象，是一个对象实例的存在，它的嘴巴是实例变量，吃饭是实例方法，米饭和菜是吃饭这个对象方法中的方法私有变量，
打比方张三、李四在一起去吃饭（2个线程），都调用了吃饭这个方法（吃饭这个方法是人类共有的），分布是土豆A与土豆B，如果不做同步，有可能2个人会夹到同一条土豆丝。
好吧，上面的比方看看就好。
二、可重入锁
如果一个线程获取了或者说抢到了cpu资源，拿到了实例对象锁，那么在实例方法中在调用其他同步方法时，依然会获取到同一个锁，因为已经抢到了，
比方说，一个屋子有3个房间（方法），张三（线程），抢到了房间1的锁，由于李四和王五压根就没进入这个屋子，所有他们俩必须等张三出来才行，这样的话
张三进过房间1后，还能获得房间2、3的锁。
这个锁指的是对象锁，或者说一个实例对象只有一把锁会更好理解。因为李四和王五想进房间2，虽然不是房间1，但是只有一把锁，这个锁在张三手上。
可重入锁个人感觉主要贡献在于可继承，如果B基础了A，那么如果操作B，获取到了实例对象B的锁，那么也可以继续获得A的锁。
三、异常释放锁
当线程出现异常时，锁会自动释放。
四、同步不具有继承
如果类A 有同步方法 methodA，类B继承了类A并重写了methodA 方法，但是没有加上同步关键字，那么实际上，B类中重写的methodA 并不是同步方法。
五、同步方法与同步代码块
之前在1中写过，这里再提及，同步代码块同样时获得的是对象锁，当不同的实例方法各自有各自的同步代码块，当线程A访问methodA 时获得实例对象锁，如果线程B访问的实例对象与线程A相同，那么线程B如想
访问methodB中的同步代码块时同样需要等线程A使用完methodA，释放对象锁，才能执行。
六、非当前实例对象锁（任意对象监视器）
优点：同一个类中的多个方法或者同一个方法中有多个代码块，为了提高性能，使用多个对象锁，来加快运行速度，或者说减少阻塞。
例如：
private Object object = new Object();
public static void main(String[] args){
Test2 test2 = new Test2();
Thread t = new Thread(new Runnable() {
@Override
public void run() {
test2.test();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
test2.test2();
}
});
t.start();
t2.start();
}
public void test2(){
synchronized (object){
System.out.println("我是第二个块"+Thread.currentThread().getName());
}
}
public void test(){
synchronized (this){
try {
System.out.println("我是第一个块 开始:"+Thread.currentThread().getName());
Thread.sleep(100);
System.out.println("我是第一个块 结束:"+Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
输出：
通过控制台打印结果可以看出，在A线程访问test方法执行的同时，B线程同样访问可test2方法。
所以，他们互不干扰，因为不是一把锁。
但是问题又出来，就因为这样提高了性能，但是又有可能会导致脏读，如果methodA与methodB 中有对同一个实例变量的写操作，那么及有可能出现脏读。
如下：
private Object object = new Object();
private static List<String> list = new ArrayList<>();
public static void main(String[] args){
Test2 test2 = new Test2();
Thread t = new Thread(new Runnable() {
@Override
public void run() {
test2.test();
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
test2.test2();
}
});
t.start();
t2.start();
try {
Thread.sleep(6000);
System.out.println(list.size());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void test2(){
synchronized (object){
judge("test2");
}
}
public void test(){
synchronized (this){
judge("test");
}
}
public void judge(String what){
try {
if(list.size() < 1){
Thread.sleep(2000);
list.add(what);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
输出结果：
出现了，以为是异步的，所以线程A和线程B都可以同时访问到judge方法，又同时进入到了if语句中，导致最终结果输出为2，而不是我们期望的1。
所以，方法就是，给judge加上同步锁：
synchronized (list){
if(list.size() < 1){
Thread.sleep(2000);
list.add(what);
}
}
这样拿到list对象锁的操作就变成同步的了~
明儿个继续~