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中的用法，称为为同步方法