读马士兵java高并发编程，引用他的代码，做个记录。
一、分析下面程序输出：
/**
* 分析一下这个程序的输出
* @author mashibing
*/ package yxxy.c_005; public class T implements Runnable { private int count = 10; public synchronized void run() {
count--;
System.out.println(Thread.currentThread().getName() + " count = " + count);
} public static void main(String[] args) {
T t = new T();
for(int i=0; i<5; i++) {
new Thread(t, "THREAD" + i).start();
}
} }
THREAD0 count = 9
THREAD4 count = 8
THREAD1 count = 7
THREAD3 count = 6
THREAD2 count = 5
分析：
启动了5个线程，thread0先拿到这把锁，开始执行，thread1-4都在等待准备抢这把锁；thread0执行完之后，释放锁；thread4率先抢到了这把锁，开始执行;执行完之后thread1又抢到了这把锁，开始执行....；
所以看到每次线程访问一次，count-1；而且thread执行的先后顺序每次执行的结果不同，因为你不知道哪个线程先执行了；
二、对比上一个程序，分析这个程序的输出：
/**
* 对比上面一个小程序，分析一下这个程序的输出
* @author mashibing
*/ package yxxy.c_006; public class T implements Runnable { private int count = 10; public synchronized void run() {
count--;
System.out.println(Thread.currentThread().getName() + " count = " + count);
} public static void main(String[] args) { for(int i=0; i<5; i++) {
T t = new T();
new Thread(t, "THREAD" + i).start();
}
} }
THREAD0 count = 9
THREAD4 count = 9
THREAD3 count = 9
THREAD1 count = 9
THREAD2 count = 9
分析：
启动了5个线程，因为每次都是new了一个t，每个线程都能锁住t，一共有5个t，5个count；所以这里5个线程执行完，count都是9；
但是因为不知道哪个线程先被cpu执行，所以thread名字的顺序是随机的；
三、同步和非同步方法是否可以同时调用？
/**
* 同步和非同步方法是否可以同时调用？
* @author mashibing
*/ package yxxy.c_007; public class T { public synchronized void m1() {
System.out.println(Thread.currentThread().getName() + " m1 start...");
try {
Thread.sleep(10000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " m1 end");
} public void m2() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + " m2 ");
} public static void main(String[] args) {
T t = new T(); new Thread(()->t.m1(), "t1").start();
new Thread(()->t.m2(), "t2").start();
} }
t1 m1 start...
t2 m2
t1 m1 end
分析：
t1线程执行m1方法，开始睡10s，在这过程之中，t2线程执行m2方法，5s之后打印了m2；由此可见在m1执行的过程之中，m2是可以运行的。
同步方法的执行过程中，非同步方法是可以执行的。只有synchronized这样的方法在运行时候才需要申请那把锁，而别的方法是不需要申请那把锁的。
new Thread(()->t.m1())这个写法是java8里面的Lambda表达式，一种简写，还可以写成这样：
public static void main(String[] args) {
T t = new T();
new Thread(t::m1, "t1").start();
new Thread(t::m2, "t2").start();*/
}
就是之前最原始的写法：
public static void main(String[] args) {
T t = new T();
new Thread(new Runnable(){
@Override
public void run() {
t.m1();
}
}, "t1").start();
new Thread(new Runnable(){
@Override
public void run() {
t.m2();
}
}, "t2").start();
}
四、对业务写方法加锁，对业务读方法不加锁，容易产生脏读问题（dirtyRead）
/**
* 对业务写方法加锁
* 对业务读方法不加锁
* 容易产生脏读问题（dirtyRead）
*/ package yxxy.c_008; import java.util.concurrent.TimeUnit; public class Account {
String name;
double balance; public synchronized void set(String name, double balance) {
this.name = name; try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
} this.balance = balance;
} public double getBalance(String name) {
return this.balance;
} public static void main(String[] args) {
Account a = new Account();
new Thread(()->a.set("zhangsan", 100.0)).start(); try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
} System.out.println(a.getBalance("zhangsan")); try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
} System.out.println(a.getBalance("zhangsan"));
}
}
0.0
100.0
分析：
主线程里面第一次读zhangsan里面的钱是0.0，第二次读是100.0；原因是set修改钱的时候过程中，sleep了2s钟；为什么sleep 2s就是放大了在线程的执行过程之中的时间差，set钱方法里面this.name=name和this.balance=balance之间可能是会被别的程序执行的；
在线程的执行过程set钱之中，尽管写的这个方法set加上了synchronized锁定了这个对象，锁定这个对象过程之中，它仍然有可能被那些非锁定的方法/非同步方法访问的；
尽管对写进行了加锁，但是由于没有对读加锁，那么有可能会读到在写的过程中还没有完成的数据，产生了脏读问题；
解决：
对读方法枷锁：
public synchronized double getBalance(String name) {
return this.balance;
}
五、一个同步方法可以调用另外一个同步方法：
一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁.
/**
* 一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁.
* 也就是说synchronized获得的锁是可重入的.(可重入的意思就是获得锁之后还可以再获得一遍)
* @author mashibing
*/
package yxxy.c_009; import java.util.concurrent.TimeUnit; public class T {
synchronized void m1() {
System.out.println("m1 start");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
m2();
} synchronized void m2() {
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m2");
}
}
分析：
对t执行m1的时候，需要在t上面加把锁，拿到这个锁了，开始执行，执行锁定的过程之中，调用了m2()；
调用m2的过程中，发现m2也是需要申请一把锁，而申请的这把锁就是当前自己已经持有的这把锁；
严格来讲，这把锁m1已经持有了，m2还能持有吗？由于是在同一个线程里面，这个是没关系的。它可以再去申请我自己已经拥有的这把锁，实际上就在这把锁上加个数字，从1变成2，锁定了2次。总而言之，再去申请当前持有的这把锁没问题，仍然会得到该对象的锁。
六、重入锁的另外一种情形，继承中子类的同步方法调用父类的同步方法
/**
* 一个同步方法可以调用另外一个同步方法，一个线程已经拥有某个对象的锁，再次申请的时候仍然会得到该对象的锁.
* 也就是说synchronized获得的锁是可重入的
* 这里是继承中有可能发生的情形，子类调用父类的同步方法
* @author mashibing
*/
package yxxy.c_010; import java.util.concurrent.TimeUnit; public class T {
synchronized void m() {
System.out.println("m start");
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("m end");
} public static void main(String[] args) {
new TT().m();
} } class TT extends T {
@Override
synchronized void m() {
System.out.println("child m start");
super.m();
System.out.println("child m end");
}
}
child m start
m start
m end
child m end
七、synchronized同步方法如果遇到异常，锁就会被释放
/**
* 程序在执行过程中，如果出现异常，默认情况锁会被释放
* 所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。
* 比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，这时如果异常处理不合适，
* 在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。
* 因此要非常小心的处理同步业务逻辑中的异常
* @author mashibing
*/
package yxxy.c_011; import java.util.concurrent.TimeUnit; public class T {
int count = 0;
synchronized void m() {
System.out.println(Thread.currentThread().getName() + " start");
while(true) {
count ++;
System.out.println(Thread.currentThread().getName() + " count = " + count);
try {
TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {
e.printStackTrace();
} if(count == 5) {
int i = 1/0; //此处抛出异常，锁将被释放，要想不被释放，可以在这里进行catch，然后让循环继续
}
}
} public static void main(String[] args) {
T t = new T(); new Thread(()->t.m(), "t1").start(); try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
} new Thread(()->t.m(), "t2").start();
} }
执行结果：
t1 start
t1 count = 1
t1 count = 2
t1 count = 3
t1 count = 4
t1 count = 5
t2 start
t2 count = 6
Exception in thread "t1" java.lang.ArithmeticException: / by zero
at yxxy.c_011.T.m(T.java:28)
at yxxy.c_011.T.lambda$0(T.java:36)
at java.lang.Thread.run(Thread.java:745)
t2 count = 7
t2 count = 8
t2 count = 9
分析：
t1线程启动后，如果int i=1/0这里抛了异常后，锁不被释放的话，t2线程就永远启动不起来，永远执行不了；
但是抛出异常之后，锁被释放了，t2得到了执行；
解决：
处理异常，锁不被释放，循环继续，t2线程永远执行不了：
/**
* 程序在执行过程中，如果出现异常，默认情况锁会被释放
* 所以，在并发处理的过程中，有异常要多加小心，不然可能会发生不一致的情况。
* 比如，在一个web app处理过程中，多个servlet线程共同访问同一个资源，这时如果异常处理不合适，
* 在第一个线程中抛出异常，其他线程就会进入同步代码区，有可能会访问到异常产生时的数据。
* 因此要非常小心的处理同步业务逻辑中的异常
* @author mashibing
*/
package yxxy.c_011; import java.util.concurrent.TimeUnit; public class T {
int count = 0;
synchronized void m() {
System.out.println(Thread.currentThread().getName() + " start");
while(true) {
count ++;
System.out.println(Thread.currentThread().getName() + " count = " + count);
try {
TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) {
e.printStackTrace();
} if(count == 5) {
try{
int i = 1/0; //此处抛出异常，锁将被释放，要想不被释放，可以在这里进行catch，然后让循环继续
}catch(Exception e){
System.out.println(e.getMessage());
}
}
}
} public static void main(String[] args) {
T t = new T(); new Thread(()->t.m(), "t1").start(); try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
} new Thread(()->t.m(), "t2").start();
} }
t1 start
t1 count = 1
t1 count = 2
t1 count = 3
t1 count = 4
t1 count = 5
/ by zero
t1 count = 6
t1 count = 7
t1 count = 8
t1 count = 9
t1 count = 10
t1 count = 11
t1 count = 12
八、volatile关键字
/**
* volatile 关键字，使一个变量在多个线程间可见
* A B线程都用到一个变量，java默认是A线程中保留一份copy，这样如果B线程修改了该变量，则A线程未必知道
* 使用volatile关键字，会让所有线程都会读到变量的修改值
*
* 在下面的代码中，running是存在于堆内存的t对象中
* 当线程t1开始运行的时候，会把running值从内存中读到t1线程的工作区，在运行过程中直接使用这个copy，并不会每次都去
* 读取堆内存，这样，当主线程修改running的值之后，t1线程感知不到，所以不会停止运行
*
* 使用volatile，将会强制所有线程都去堆内存中读取running的值
*
* 可以阅读这篇文章进行更深入的理解
* http://www.cnblogs.com/nexiyi/p/java_memory_model_and_thread.html
*
* volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
* @author mashibing
*/
package yxxy.c_012; import java.util.concurrent.TimeUnit; public class T {
volatile boolean running = true; //对比一下有无volatile的情况下，整个程序运行结果的区别
void m() {
System.out.println("m start");
while(running) {
}
System.out.println("m end!");
} public static void main(String[] args) {
T t = new T(); new Thread(t::m, "t1").start(); try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
} t.running = false;
} }
分析：
不加volatile是不行的，线程1没法结束，那么volatile到底是干嘛的？
线程之间要让running这个值进行可见，这里要涉及到java的内存模型，java对于线程处理的内存模型；
在jmm（java memory model）里面有个内存它叫主内存，我们所熟识的栈内存，堆内存都可以认为是主内存；每一个线程在执行的过程之中，它有一个线程自己的一块内存，（实际上不能认为这块是内存，有可能它是内存，还有cpu上的缓冲区，是一个统称，就是线程存放它自己变量的一块内存），如果两个cpu在运行不同线程的话，每个线程上都有自己的一块缓冲区，缓冲区就是把主内存JMM里面的内容读过来在缓冲区里面进行修改，如果+1，+1加了好多次再写回去；
现在有个running在主内存里面，值是true，占一个字节；
第一个线程启动的时候会把这个字节copy到自己的缓冲区里面，cpu在处理的过程之中就不再去主内存里面读了；它在运行这个线程的过程之中，由于这个cpu非常的忙，在while(running)里面，没空再去主线程里面去刷一下running值了；它一直读自己缓存里面的内容，running永远是true；
第二个主线程里面，它首先也是把running读到它自己的缓冲区，然后把running改成false，发现running已经改了那就把running写回到主内存里面去；写回到主内存之后，但是第一个线程它没有在主内存重新读啊，所以第一个线程永远结束不了；
加了volatile，第一个线程运行中，不是要求你每次while(running)循环的时候都要到主内存里面读一次running的值，而是说一旦主内存running这个值发生改变后会通知别的线程，说你们的缓冲区里面内容过期了请重新读一下，第一个线程再去读的时候running已经改了，所以线程结束了。
加了volatile的意思就是当running改了后会通知其他的所有线程的缓冲区，说你们那边的值已经过期了，请你们再去主内存里面重新读一下。
而并不是通知所有的线程cpu执行的时候每次用的时候都要去主内存读一下，不是，是写完之后进行缓存过期通知。
要保证线程之间的可见性，那么需要对两个线程共同访问的变量加上volatile；如果不想加volatile那只能用synchronized；但volatile的效率要比synchronized高的多；所以在很多高并发的框架里面好多的volatile关键字都在用；比如JDK的并发容器的源码；能用volatile的时候就不要加锁，程序的并发性就要提高很多；
图：
九、volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
/**
* volatile并不能保证多个线程共同修改running变量时所带来的不一致问题，也就是说volatile不能替代synchronized
* 运行下面的程序，并分析结果
* @author mashibing
*/
package yxxy.c_013; import java.util.ArrayList;
import java.util.List; public class T {
volatile int count = 0;
void m() {
for(int i=0; i<10000; i++) count++;
} public static void main(String[] args) {
T t = new T(); List<Thread> threads = new ArrayList<Thread>(); for(int i=0; i<10; i++) {
threads.add(new Thread(t::m, "thread-"+i));
} threads.forEach((o)->o.start()); threads.forEach((o)->{
try {
o.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}); System.out.println(t.count); } }
volatile和synchronized区别？
volatile只保证可见性，并不保证原子性；
synchronized既保证可见性，又保证原子性；但效率要比volatile低不少；
如果只需要保证可见性的时候，使用volatile，不要使用synchronized；
Thread.join()方法解释见：https://www.cnblogs.com/huangzejun/p/7908898.html
十、对比上一个程序，可以用synchronized解决
/**
* 对比上一个程序，可以用synchronized解决，synchronized可以保证可见性和原子性，volatile只能保证可见性
* @author mashibing
*/
package yxxy.c_014; import java.util.ArrayList;
import java.util.List; public class T {
int count = 0;
synchronized void m() {
for (int i = 0; i < 10000; i++) count++;
} public static void main(String[] args) {
T t = new T(); List<Thread> threads = new ArrayList<Thread>(); for (int i = 0; i < 10; i++) {
threads.add(new Thread(t::m, "thread-" + i));
} threads.forEach((o) -> o.start()); threads.forEach((o) -> {
try {
o.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}); System.out.println(t.count);
}
}
运行结果：100000
如果你只是处理这种++，--，这一类的操作，只是涉及到一些简单的数字运算，在java里面提供了一些原子类；见下面十一：
十一、使用AtomXXX类
/**
* 解决同样的问题的更高效的方法，使用AtomXXX类
* AtomXXX类本身方法都是原子性的，但不能保证多个方法连续调用是原子性的
* @author mashibing
*/
package yxxy.c_015; import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger; public class T {
AtomicInteger count = new AtomicInteger(0); void m() {
for (int i = 0; i < 10000; i++)
count.incrementAndGet(); //count++
} public static void main(String[] args) {
T t = new T(); List<Thread> threads = new ArrayList<Thread>(); for (int i = 0; i < 10; i++) {
threads.add(new Thread(t::m, "thread-" + i));
} threads.forEach((o) -> o.start()); threads.forEach((o) -> {
try {
o.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}); System.out.println(t.count);
}
}
运行结果：100000
AtomicInteger：原子性操作的int类型；
incrementAndGet(): 原子方法，你可以认为它是加了synchronized的，当然它内部实现不是用synchronized的而是用系统相当底层的实现来去完成的；它的效率要比synchronized高很多；
十二、synchronized优化
/**
* synchronized优化
* 同步代码块中的语句越少越好
* 比较m1和m2
* @author mashibing
*/
package yxxy.c_016; import java.util.concurrent.TimeUnit; public class T { int count = 0; synchronized void m1() {
//do sth need not sync
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
count ++; //do sth need not sync
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
} void m2() {
//do sth need not sync
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//业务逻辑中只有下面这句需要sync，这时不应该给整个方法上锁
//采用细粒度的锁，可以使线程争用时间变短，从而提高效率
synchronized(this) {
count ++;
}
//do sth need not sync
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
分析：
m2()的并发效率要比m1()高不少；细粒度的锁执行效率要比粗粒度的锁执行效率要高不少；
十三、避免将锁定对象的引用变成另外的对象，例子：
/**
* 锁定某对象o，如果o的属性发生改变，不影响锁的使用
* 但是如果o变成另外一个对象，则锁定的对象发生改变
* 应该避免将锁定对象的引用变成另外的对象
* @author mashibing
*/
package yxxy.c_017; import java.util.concurrent.TimeUnit; public class T {
Object o = new Object(); void m() {
synchronized(o) {
while(true) {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName());
}
}
} public static void main(String[] args) {
T t = new T();
//启动第一个线程
new Thread(t::m, "t1").start(); try {
TimeUnit.SECONDS.sleep(3);
} catch (InterruptedException e) {
e.printStackTrace();
}
//创建第二个线程
Thread t2 = new Thread(t::m, "t2"); t.o = new Object(); //锁对象发生改变，所以t2线程得以执行，如果注释掉这句话，线程2将永远得不到执行机会 t2.start();
}
}
运行结果：
t1
t1
t1
t2
t1
t2
t1
t2
t1
t2
t1
t2
t1
t2
t1
t2
t1
t2
t1
...
分析：
t.o = new Object();锁的对象发生改变，就不需要锁原来的对象，直接锁新对象就行了；而新对象还没有锁的，所以t2线程就被执行了；
所以，这就证明这个锁是锁在什么地方？是锁在堆内存里new出来的对象上，不是锁在栈内存里头o的引用，不是锁的引用，而是锁new出来的真正的对象；
锁的信息是记录在堆内存里的。
十四、不要以字符串常量作为锁定对象
/**
* 不要以字符串常量作为锁定对象
* 在下面的例子中，m1和m2其实锁定的是同一个对象
* 这种情况还会发生比较诡异的现象，比如你用到了一个类库，在该类库中代码锁定了字符串“Hello”，
* 但是你读不到源码，所以你在自己的代码中也锁定了"Hello",这时候就有可能发生非常诡异的死锁阻塞，
* 因为你的程序和你用到的类库不经意间使用了同一把锁
*
* jetty
*
* @author mashibing
*/
package yxxy.c_018; public class T { String s1 = "Hello";
String s2 = "Hello"; void m1() {
synchronized(s1) { }
} void m2() {
synchronized(s2) { }
}
}