Java并发编程（三）synchronized实现简单同步

一、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();
			}
		}

Java并发编程（三）synchronized实现简单同步

一、synchronized应用的简单示例

二、关于多线程不安全及锁机制的简单理解

三、synchronized关键字的使用

3.1使用同步代码块

3.1使用同步方法

Java併發編程（三）synchronized實現簡單同步

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結