synchronized简单示例

一、synchronized应用的简单示例

下面两段代码示例，分别用同步块，同步方法完成两个线程共同操作的计数器，计数到10。

package concurrency;

public class TwoThreadCounter {

    public static volatile boolean  goon = false;
    public static int nums = 0;

    public static void main(String[] args) {
        Thread counter1 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(goon){
                    synchronized (TwoThreadCounter.class) {
                        nums++;
                        System.out.println(Thread.currentThread().getName() + "\t" + nums);
                        if(nums == 10) {
                            goon = false;
                            TwoThreadCounter.class.notifyAll();
                        }else{
                            try {
                                TwoThreadCounter.class.notifyAll();
                                TwoThreadCounter.class.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }

                    }
                }
            }
        }, "counter1");
        Thread counter2 = new Thread(new Runnable() {
            @Override
            public void run() {
                while(goon) {
                    synchronized (TwoThreadCounter.class) {
                        nums++;
                        System.out.println(Thread.currentThread().getName() + "\t" + nums);
                        if(nums == 10) {
                            goon = false;
                            TwoThreadCounter.class.notifyAll();
                        }else{
                            try {
                                TwoThreadCounter.class.notifyAll();
                                TwoThreadCounter.class.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }

            }
        }, "counter2");

        goon = true;
        counter1.start();
        counter2.start();


        try {
            counter1.join();
            counter2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

看下输出结果：

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关键字的使用

上面通过类比已经说明了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();
			}
		}