java多线程3--synchronized

synchronized是java的一个关键字，它保证了同一时刻最多只能有一个线程访问被synchronized修饰的代码块

synchronized特性：

    1、object中被synchronized修饰的代码块同一时间只能由一个进程访问

    2、当某个进程访问了synchronized修饰的代码块，其他进程仍然可以访问其他未被synchronized修饰的代码块

    3、当某个进程访问了synchronized修饰的代码块，这个进程就拿到了该Object的对象锁，其他进程访问该Object的任何同步区域都会被阻塞

总的来说，一个Object只有一个对象锁，当某个进程拿到这个对象锁时，其他进程对这个Object的同步区域的访问都会被阻塞，但仍然可以访问这个Object的非同步区域。

示例1：object中被synchronized修饰的代码块同一时间只能由一个进程访问

<span style="font-size:14px;">public class testSynchronized {
	public static void main(String[] args){
		myThread mt = new myThread();
		Thread t1 = new Thread(mt, "T1");
		Thread t2 = new Thread(mt, "T2");
		t1.start();
		t2.start();
	}
}
class myThread implements Runnable{
	private int num;
	public void run() {
		synchronized (this) {
			for(num=0;num<5;num++){
				try {
					Thread.sleep(10);
					System.out.print(Thread.currentThread().getName()+":"+num+"--");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
		}
	}
	
}</span>

输出结果为：T1:0--T1:1--T1:2--T1:3--T1:4--T2:0--T2:1--T2:2--T2:3--T2:4--

如果把synchronized(this)去掉myThread类改为

<span style="font-size:14px;">class myThread implements Runnable{
	private int num;
	public void run() {
		//synchronized (this) {
			for(num=0;num<5;num++){
				try {
					Thread.sleep(10);
					System.out.print(Thread.currentThread().getName()+":"+num+"--");
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				
			}
		//}
	}
	
}</span>

输出结果为T2:0--T1:0--T1:2--T2:2--T1:4--T2:4--

示例2：当某个进程访问了synchronized修饰的代码块，其他进程仍然可以访问其他未被synchronized修饰的代码块

<span style="font-size:14px;">public class testSynchronized2 {

	public static void main(String[] args) {
		final myThread2 mt2 = new myThread2();
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				mt2.synchronizedFunction();
			}
		},"T1");
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				mt2.notSynchronizedFunction();
			}
		},"T2");
		t1.start();
		t2.start();
	}

}
class myThread2{
	public synchronized void synchronizedFunction(){
		int num;
		for(num=0;num<4;num++){
			try {
				Thread.sleep(100);
				System.out.print(Thread.currentThread().getName()+":"+num+"--");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
	}
	public void notSynchronizedFunction(){
		int num;
		for(num=0;num<4;num++){
			try {
				Thread.sleep(100);
				System.out.print(Thread.currentThread().getName()+":"+num+"--");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
	}
}</span>

结果为：T2:0--T1:0--T2:1--T1:1--T2:2--T1:2--T1:3--T2:3--
示例3：当某个进程访问了synchronized修饰的代码块，这个进程就拿到了该Object的对象锁，其他进程访问该Object的任何同步区域都会被阻塞

<span style="font-size:14px;">public class testSynchronized2 {

	public static void main(String[] args) {
		final myThread2 mt2 = new myThread2();
		Thread t1 = new Thread(new Runnable() {
			public void run() {
				mt2.synchronizedFunction();
			}
		},"T1");
		Thread t2 = new Thread(new Runnable() {
			public void run() {
				mt2.notSynchronizedFunction();
			}
		},"T2");
		t1.start();
		t2.start();
	}

}
class myThread2{
	public synchronized void synchronizedFunction(){
		int num;
		for(num=0;num<4;num++){
			try {
				Thread.sleep(100);
				System.out.print(Thread.currentThread().getName()+":"+num+"--");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
	}
	public synchronized void notSynchronizedFunction(){
		int num;
		for(num=0;num<4;num++){
			try {
				Thread.sleep(100);
				System.out.print(Thread.currentThread().getName()+":"+num+"--");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}

		}
	}
}</span>

输出结果为：T1:0--T1:1--T1:2--T1:3--T2:0--T2:1--T2:2--T2:3--

synchronized两种用法：一种是想示例1中的用法，被称为同步代码块；第二种是像示例2、3中的用法，称为为同步方法