一、synchronized应用的简单示例
下面两段代码示例，分别用同步块，同步方法完成两个线程共同操作的计数器，计数到10。
import java.util.concurrent.atomic.AtomicBoolean;
public class TwoThreadCounter {
public static Integer counter = 0;
public static AtomicBoolean goon = new AtomicBoolean(false);
public static void main(String[] args) {
Thread counter1 = new Thread(new Runnable() {
@Override
public void run() {
while(goon.get()){
synchronized (TwoThreadCounter.class) {
counter++;
System.out.println(Thread.currentThread().getName() + "\t" + counter);
if(counter == 10) {
goon.set(false);
}else{
try {
TwoThreadCounter.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}, "counter1");
Thread counter2 = new Thread(new Runnable() {
@Override
public void run() {
while(goon.get()) {
synchronized (TwoThreadCounter.class) {
counter++;
System.out.println(Thread.currentThread().getName() + "\t" + counter);
if(counter == 10) {
goon.set(false);
}else{
try {
TwoThreadCounter.class.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
}
}, "counter2");
goon.set(true);
boolean hasStart = false;
while(goon.get()){
if(!hasStart) {
counter1.start();
counter2.start();
hasStart = true;
}
synchronized (TwoThreadCounter.class) {
TwoThreadCounter.class.notify();
}
}
}
}
看下输出结果：
counter1 1 counter2 2 counter1 3 counter2 4 counter1 5 counter2 6 counter1 7 counter2 8 counter1 9 counter2 10
sysnchronized也可以用于修饰方法，普通方法和静态方法都可以，我们现在用普通同步方法改写上面的代码，因为静态方法术语类对象，而普通方法属于类的实例，所以如果想用sysnchronized修饰普通方法来实现功能，要在有一个实例，代码如下：
import java.util.concurrent.atomic.AtomicBoolean;
public class TwoThreadCounterSynNormalMethod {
public static Integer counter = 0;
public static AtomicBoolean goon = new AtomicBoolean(false);
public TwoThreadCounterSynNormalMethod() {}
public synchronized void counterIncreace(){
counter ++;
System.out.println(Thread.currentThread().getName() + "\t" + counter);
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
TwoThreadCounterSynNormalMethod ttcsnm = new TwoThreadCounterSynNormalMethod();
Thread counter1 = new Thread(new Runnable() {
@Override
public void run() {
while(goon.get()){
ttcsnm.counterIncreace();
if(counter == 10) {
goon.set(false);
}
}
}
}, "counter1");
Thread counter2 = new Thread(new Runnable() {
@Override
public void run() {
while(goon.get()) {
ttcsnm.counterIncreace();
if(counter == 10) {
goon.set(false);
}
}
}
}, "counter2");
goon.set(true);
boolean hasStart = false;
while(goon.get()){
if(!hasStart) {
counter1.start();
counter2.start();
hasStart = true;
}
synchronized (ttcsnm) {// 这里很重要，因为对普通方法使用synchronized关键字修饰，其实是把调用该方法的实例作为了锁对象
ttcsnm.notifyAll(); //所以当需要唤醒时，是调用的ttcsnm.notiffyAll();
}
}
}
}
输出结果是一样的。
二、关于多线程不安全及锁机制的简单理解
synchronized关键字，用来实现线程同步，暂时抛弃它内部复杂的实现，对代码运行做一个类比：
代码的某几行、或一个方法都是实现一个具体业务逻辑的功能模块，他们都是需要线程来执行的，他们之间的关系是这样的：
线程通过逐个执行功能模块来实现程序整体功能，现在对应一个更具体的场景：发工资。在这个场景中每一个线程对应一个工人，发工资对应的功能模块流程是：工人进入办公室，在办公室有一份公司的财务单，财务单上写的是当前公司剩余的资金数量，工人进入之后，拿走自己应得的工资，然后更新财务单，更新为原有资金数量减去自己所拿走的数量后剩余的资金数量，但是线程对应的这个工人有个不能改掉的习惯，他看到工资单后，先自己复印一份工资单，然后在复印的单子上改，改完后用自己的副本替换当前的那一份（它不记得之前是多少），流程如下：
现在是一个工人，不会存在什么问题，现在假设有两个工人，问题就来了，假设他们两个一起进了这个房间（功能模块），并且工人B在工人A替换账单之前看到了账单
A拿了40后，账单应改为60，但在A替换前，B看到了未被替换的账单，此时B拿着写有100的复印件，取走了自己的20，然后更改手里的账单为80，现在A手里有一张将要替换的账单，数量是60，B手里也有一张将要替换的账单，数量是80，此时无论哪个工人把自己手里的账单替换原有账单，数量都是不正确的。
为了解决这个问题，就需要上帝（程序猿）来协助了，上帝说：我指定XXX作为守卫在入口处守着，守卫有这么几个特点：
1、他手里握着一个入场券，每次仅允许一个工人进去，进去时把入场券给这个工人，其他人在门口排队等着
2.上一个工人领完工资了，守卫会把入场券拿过来，允许在入口处等着的人获得入场券
3.守卫的权利极大，他可以剥夺已经进去的工人继续完成领工资这件事的权利，把他的入场券拿过来，让它也处于等待的状态，当守卫手里有入场券的时候，他就可以在任何时间通知其他等待的人。
有了守卫后，领工资这件事就变得有秩序的，从一个工人的角度来看，是这样的：
工人X到达领工资的地点，先看看守卫手里的入场券还有没有，有的话，他就取过来，进去领工资，没有的话，他就知道入场券已经被其他工人持有，此时如果在他之前已经有很多人在等，他就排在队尾等候，假如现在里面的人工资拿完了，守卫就把入场券再取回来，当守卫手里有券时，守卫可以做两件事：
1.他可以拿着入场券向排队的所有人说，可以下一个人进了，这时，所有排队的人都听到了，大家都想进，那就要打架了！互相竞争，此时有一部分人是比较有优势的，比如职位高的人，有特权，那么他得到入场券的概率就大。
2.另外一种情况就是守卫只和队伍最前面的人说，这时候后面人是不知道的，只有第一个人接受到了消息，如果他现在的确可以领工资的话，就可以顺利进去了。
假如现在工人X正在拿工资，守卫突然进到屋子里面来，抢走了工人X手里的券，那么工人X只能待着一动不动，房子也不能出，但他此时他可以和队列里其他人一样，可以接收守卫唤醒的信息，现在券又到了守卫手里，守卫现在又可以继续做那两件事。
又轮到工人X了，从上次没做完的那里开始，他领完工资后，在出口位置，把券归还给守卫。
上面的场景，可以在代码中找到相对应的地方：1.工人是线程 2.守卫可以是任何对象obj，程序猿用synchronized关键字指定谁就是谁 3.告诉队列第一个人可以进了，就是obj.notify() 4.告诉所有人就是obj.notifyAll() 5.守卫想让正在取工资的人放下手中的券回队列等候，那么务必务必和已经拿到券的人在同一间房子里面，使用obj.wait()让当前工人等候。
三、synchronized关键字的使用
上面通过类比已经说明了synchronized实现同步时涉及到的方法以及含义，涉及到的几个方法分别为：obj.wait()、obj.notify()、obj.notifyAll()，这几个方法必须在同步块中调用，synchronized关键字只要作用就是指定谁是锁，在Java中每个对象都可以作为锁。
主要有三种形式：
- 对于普通同步方法，锁是当前的实例对象。在上面的第二个代码示例中，用synchronized修饰普通方法，调用这个方法的实例是ttcsnm，那么要进入这个方法，就要取得实例对象ttcsnm对应的锁，所以我在唤醒时，需要调用ttcsnm
- 对于静态同步方法，锁是当前类的Class对象。可以类比普通同步方法，普通同步方法属于实例，所以要进入同步方法，需要获得实例对应的锁，而静态方法属于类，调用时也通过类名来调用，所以用synchronized关键字修饰静态方法，那么要访问该方法，需要拿到类对象对应的锁。
- 对于同步块，synchronized后面括号里的对象就是锁，如上面第一个代码示例所示，用的是类对象TwoThreadCounter.class作为锁，要访问同步块中的内容就必须拿到这个锁。
3.1使用同步代码块
第一个示例中，使用的是同步块，同步块的书写遵循以下格式：
synchronized (obj) {
// 执行内容
}
obj即指定的锁，任何对象均可以，执行内容即用户要完成的业务逻辑，再回到代码示例
synchronized (TwoThreadCounter.class) { //此处指定TwoThreadCouter的类对象为锁
counter++; //这里是真正要完成的功能，即每次让计数器的值增加1
System.out.println(Thread.currentThread().getName() + "\t" + counter);
if(counter == 10) { // 判断如果当前技术器增加到10，那就停止，让线程停止的方式，此处选择使用atomicBooelan类来作为一个标志，如果其值为false,线程看到后就不再继续进行
goon.set(false);
}else{
try {
TwoThreadCounter.class.wait(); // 这里很关键，当一个线程对计数器进行加1操作后，如果没有累加到10，就需要另外一个线程继续加
} catch (InterruptedException e) { // 所以需要让当前线程放弃锁，根据上面分析的，想剥夺锁，必须在同步块内部，调用obj.wait()方法
e.printStackTrace(); // 这个方法会让当前线程在此方法等待（不是阻塞），直到线程死亡或被唤醒才能从该方法返回
}
}
} // 当线程成功执行完同步代码块，出这个"｝"时，会主动调用notifyall()方法。
两个线程的同步块内容是一样的，当前线程拿到锁，对计数器执行加一操作，然后判断是否结束，如果没结束，就需要放弃锁，原地等待，让另外一个线程有机会获得锁，并执行相同的功能。另外一个线程执行相同的操作后，也在wait()方法处等待，所以此时需要另外在外面唤醒
while(goon.get()){
if(!hasStart) {
counter1.start();
counter2.start();
hasStart = true;
}
synchronized (TwoThreadCounter.class) {
TwoThreadCounter.class.notify();
}
}
这段代码由主线程来执行，完成对两个线程的控制，当执行计数器加一操作的两个线程均运行到TwoThreadCounter.class.wait() 方法时，两个线程放弃锁，同时进入等待状态，所以在主线中，main线程可以顺利获得锁，进入同步块
synchronized (TwoThreadCounter.class) {
TwoThreadCounter.class.notify();
}// 当主线程执行完同步块时，才会释放锁，调用notify方法并不释放锁
在同步块中，调用TwoThreadCounter.class.notify()，此时会唤醒等待队列中的第一个线程，允许该线程拥有获得锁的机会，但此时锁依然在主线程手里，只有当主线程退出同步块时，才会把锁释放掉，被唤醒的线程才能获得锁。
这样，处于排队的线程可重新获得锁，从wait()方法返回，继续执行，再判断是否结束了，如果没有结束，重新尝试获得锁。
3.1使用同步方法
对于同步方法，注意锁对象是调用该方法的实例即可，所以在唤醒时，要用实例来调用notifyAll（）方法。
while(goon.get()){
if(!hasStart) {
counter1.start();
counter2.start();
hasStart = true;
}
synchronized (ttcsnm) {// 这里很重要，因为对普通方法使用synchronized关键字修饰，其实是把调用该方法的实例作为了锁对象
ttcsnm.notifyAll(); //所以当需要唤醒时，是调用的ttcsnm.notiffyAll();
}
}