Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然可以访问该object中的非加锁代码块。
一、synchronized同步方法
1.synchronized 同步方法，为对象锁
public class ExceptionReleaseLock {
public synchronized void testLockException(){
if (Thread.currentThread().getName().equals("A")){
System.out.println("线程名字为:"+Thread.currentThread().getName()+" 开始运行时间:"+System.currentTimeMillis());
for(int i=0;i<200;i++){
while(i>20){
System.out.println("i="+i);
Integer.parseInt("abcd");
}
}
}else{
System.out.println("B线程运行时间:"+System.currentTimeMillis());
}
}
}
2.synchronized 锁重入
当线程请求一个由其它线程持有的对象锁时，该线程会阻塞，而当线程请求由自己持有的对象锁时，如果该锁是重入锁,请求就会成功,否则阻塞.
我们来看看synchronized,它拥有强制原子性的内置锁机制,是一个重入锁,所以在使用synchronized时,当一个线程请求得到一个对象锁后再次请求此对象锁,可以再次得到该对象锁,就是说在一个synchronized方法/块的内部调用本类的其他synchronized方法/块时，是永远可以拿到锁。否则，就会造成死锁。
/**
* Created by Administrator on 2015/12/30 0030.
*
* 锁重入机制
*/
public class LockSyn {
public synchronized void a(){
System.out.println("a()");
b();
}
public synchronized void b(){
System.out.println("b()");
c();
}
public synchronized void c(){
System.out.println("c()");
}
}
public class TestLockSyn {
public static void main(String[] args){
new LockSyn().a();
}
}
输出结果：
a() b() c()
当存在继承关系时，子类可以通过可重入锁调用父类的同步方法。
public class Animal {
synchronized public void eat(){
System.out.println("Animal eat foods");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public class Cat extends Animal {
synchronized public void eatFish(){
System.out.println("cat eatFish...");
try {
Thread.sleep(2000);
this.eat();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
测试：
public class TestAnimal {
public static void main(String[] args){
Cat cat = new Cat();
cat.eatFish();
}
}
输出：
cat eatFish... Animal eat foods
我们再来看看重入锁是怎么实现可重入性的，其实现方法是为每个锁关联一个线程持有者和计数器，当计数器为0时表示该锁没有被任何线程持有，那么任何线程都可能获得该锁而调用相应的方法；当某一线程请求成功后，JVM会记下锁的持有线程，并且将计数器置为1；此时其它线程请求该锁，则必须等待；而该持有锁的线程如果再次请求这个锁，就可以再次拿到这个锁，同时计数器会递增；当线程退出同步代码块时，计数器会递减，如果计数器为0，则释放该锁。
3. 发生异常，锁自动释放
public class ExceptionReleaseLock {
public synchronized void testLockException(){
if (Thread.currentThread().getName().equals("A")){
System.out.println("线程名字为:"+Thread.currentThread().getName()+" 开始运行时间:"+System.currentTimeMillis());
for(int i=0;i<200;i++){
while(i>20){
System.out.println("i="+i);
Integer.parseInt("abcd");
}
}
}else{
System.out.println("B线程运行时间:"+System.currentTimeMillis());
}
}
}
public class ExceptionReleaseThread1 extends Thread {
private ExceptionReleaseLock exceptionReleaseLock;
public ExceptionReleaseThread1(ExceptionReleaseLock lock){
this.exceptionReleaseLock=lock;
}
@Override
public void run() {
exceptionReleaseLock.testLockException();
}
}
public class ExceptionReleaseThread2 extends Thread {
private ExceptionReleaseLock exceptionReleaseLock;
public ExceptionReleaseThread2(ExceptionReleaseLock lock){
this.exceptionReleaseLock=lock;
}
@Override
public void run() {
exceptionReleaseLock.testLockException();
}
}
测试：
/**
* Created by Administrator on 2015/12/30 0030.
*
* 发生异常后，锁自动释放
*/
public class TestExceptionRelease {
public static void main(String[] args){
ExceptionReleaseLock lock = new ExceptionReleaseLock();
ExceptionReleaseThread1 a = new ExceptionReleaseThread1(lock);
ExceptionReleaseThread2 b = new ExceptionReleaseThread2(lock);
a.setName("A");
b.setName("B");
a.start();
b.start();
}
}
输出结果：
A线程发生异常后释放了锁，线程B正常执行。
4. 同步不具有继承性.
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("noSynchronized ....");
}
}
需要在方法前加上synchronized同步。
二、synchronized 同步语句块