线程

• 线程安全
  当多个线程访问某一个类(对象或方法)时,这个类始终都能表现出正确的行为,那么这个类(对象或方法)就是线程安全的。

• synchronized
  可以在任意对象及方法上加锁,而加锁的这段代码称为"互斥区"或"临界区"。

• 示例：
  

总结：
当多个线程访问myThread的run方法时,以排队的方式进行处理(这里排队时按照cpu分配的先后顺序而定的),一个程序想要执行synchronized修饰的方法里的代码,首先要尝试获得锁,如果拿到锁,执行synchronized代码体内容;拿不到锁,这个线程就会不断地尝试获得这把锁,直到拿到为止,而且是多个线程同时去竞争这把锁。(也就是会有锁竞争的问题)。

---

• 多个线程多个锁：
  多个线程，每个线程都可以拿到自己指定的锁,分别获得锁之后,执行synchronized方法提的内容。

public class MultiThread {
	private  int num = 0;
	public synchronized void printNum(String tag){
		try{
			if(tag.equals("a")){
				num = 100;
				System.out.println("tag a,set num over!");
				Thread.sleep(1000);
			} else{
				num = 200;
				System.out.println("tag b,set num over!");
			}
			System.out.println("tag" + tag + ",num = " + num);
		} catch(InterruptedException e){
			e.printStackTrace();
		}
	}
	//注意观察run方法的输出顺序
	public static void main(String args[]){
		//两个不同的对象
		final MultiThread m1 = new MultiThread();
		final MultiThread m2 = new MultiThread();
		Thread t1 = new Thread(new Runnable(){

			@Override
			public void run() {
				m1.printNum("a");;
			}
		});
		Thread t2 = new Thread(new Runnable(){
			@Override
			public void run() {
				m2.printNum("b");
			}
		});
		t1.start();
		t2.start();
	}
}

输出的结果：

tag a,set num over!
tag b,set num over!
tagb,num = 200
taga,num = 100

加了static：

输出结果：

tag b,set num over!
tagb,num = 200
tag a,set num over!
taga,num = 100

示例总结：
关键字synchronized取得的锁都是对象锁,而不是把一段代码(方法)当作锁,所以示例代码中那个先执行synchronized关键字的方法,那个线程就持有该方法所属对象的锁(Lock),两个对象,线程获得的就是两个不同的锁,他们互不影响。
有一个情况则是相同的锁,即在静态方法上加synchronized关键字,表示锁定,class类,类一级别的锁(独占.class类)。

---

对象锁的同步和异步

同步：synchronized
同步的概念就是共享，要牢牢记住“共享”这两个字，如果不是共享的资源，就没有必要进行同步。
异步：asynchronized
异步的概念就是独立，相互之间不受任何制约，例如http中，在页面发起的Ajax请求，我们还可以继续浏览或操作页面的内容，二者之间没有任何关系。

同步的目的就是为了线程安全，对于线程来说，需要满足两个特性：
原子性（同步）
可见性

public class MyObject {
	public synchronized void method1(){
		try {
			System.out.println(Thread.currentThread().getName());
			Thread.sleep(4000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	
	public void method2(){
		System.out.println(Thread.currentThread().getName());
	}
	
	public static void main(String args[]){
		
		final MyObject mo = new MyObject();
		/**
		 * 分析：
		 * t1线程先持有object对象的Lock锁，t2线程可以以异步的方式调用对象中的非synchronized修饰的方法
		 * t1线程先持有object对象的Lock锁，t2线程如果在这个时候调用对象中的同步(synchronized)的方法则需等待，也就是同步
		 */
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				mo.method1();
			}
		},"t1");
		
		Thread t2 = new Thread(new Runnable(){

			@Override
			public void run() {
				mo.method2();
			}
		},"t2");
		
		t1.start();
		t2.start();
	}
}

分析：
这里的method1和method2一个加了synchronized，一个没加，两个线程调用同一个对象的不同方法，此时t2线程可以异步的执行未加synchronized关键字的method2，两个线程没有任何关系，输出：t1，t2，4秒后结束进程。

分析：
method1和method2都加了synchronized关键字，两个线程调用同一个方法的不同但有synchronized的方法，需要同步进行，即在t1线程进入method1方法时，获得MyObject的对象锁，t2线程进入method2方法就要等待t1执行完后将对象锁释放，再获得对象锁才能执行t2方法。输出：t1，等待4秒，t2。

---

锁重入：
关键字synchronized拥有锁重入的功能，也就是在使用synchronized时，当一个线程得到一个对象的锁后，再次请求此对象时是可以再次得到该对象的锁。

• synchronized应用1（锁重入）：

public class SyncDubbo1 {

	public synchronized void method1(){
		System.out.println("method1...");
		method2();
	}
	public synchronized void method2(){
		System.out.println("method2..");
		method3();
	}
	public synchronized void method3(){
		System.out.println("method3...");
	}
	
	public static void main(String args[]){
		
		final SyncDubbo1 sd = new SyncDubbo1();
		
		Thread t1 = new Thread(new Runnable(){
			@Override
			public void run() {
				sd.method1();
			}
		});
		t1.start();
	}
}

应用2（字父类的方法同步）：

public class SyncDubbo2 {

	static class Main{
		public int i = 10;
		public synchronized void operationSup(){
			try {
				i--;
				System.out.println("Main print i = " + i);
				Thread.sleep(100);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}
	
	static class Sub extends Main{
		public synchronized void operationSub(){
			try {
				while(i>0){
					i--;
					System.out.println("Sub print i = " + i);
					Thread.sleep(100);
					this.operationSup();
				}
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
	
	public static void main(String args[]){
		Thread t1 = new Thread(new Runnable(){

			@Override
			public void run() {
				Sub sub = new Sub();
				sub.operationSub();
			}
		});
		t1.start();
	}
}

---

出现异常，锁自动释放：
对于web应用程序，异常释放锁的情况，如果不及时处理，很可能对你的应用程序业务逻辑产生严重的错误，比如你现在执行一个队列任务，很多对象都去在等待一个对象正确执行完毕再去释放锁，但是第一个对象由于异常的出现，导致业务逻辑没有正常执行完毕，就释放了锁，那么可想而知后续的对象执行的都是错误的逻辑，所以这一点要引起注意，在编写代码的时候，一定要考虑周全。

public class SyncException {
	private int i = 0;
	public synchronized void operation(){
		while(i<=15){
			try {
				i++;
				Thread.sleep(200);
				System.out.println(Thread.currentThread().getName() + ",i = " + i);
				if(i == 10){
					Integer.parseInt("a");
					//throw new RuntimeException();
				}
			} catch (Exception e) { //InterruptedException
				e.printStackTrace();
				System.out.println("log info i = " + i);
				//throw new RuntimeException();
				//continue;
			}
		}
	}
	
	public static void main(String args[]){
		final SyncException se = new SyncException();
		
		Thread t1 = new Thread(new Runnable(){

			@Override
			public void run() {
				se.operation();
			}
		});
		t1.start();
	}
}