synchronized官方定义：
同步方法支持一种简单的策略防止线程干扰和内存一致性错误，如果一个对象对多个线程可见，则对该对象变量的所有读取或写入都是通过同步方法完成的（这一个synchronized关键字完成的）。
通俗的来讲：
synchronized关键字：能够保证同一时刻最多只有一个线程执行该段代码，以达到保证并发安全的效果。
synchronized的两个用法：
1.对象锁：包括方法锁（默认锁对象是当前实例对象）和同步代码块锁（自己指定锁的对象）；
2.类锁：synchronized修饰的静态的方法或指定锁为Class对象；
代码展示：
对象锁：针对的是同一个对象（即下列中的instance对象），如果是两个不同的对象，对象锁就不能起到同步的作用（可以自己创两个对象测试），而类锁可以。
* 对象锁的代码块形式
* @author Administrator
*
*/
public class SynchronizeTest01 implements Runnable{
static SynchronizeTest01 instance = new SynchronizeTest01();
Object obj = new Object();
@Override
public void run() {
//锁自定义对象
synchronized (obj) {
System.out.println("我是对象锁代码块,我叫"+Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"玩完了");
}
//第一种锁当前对象
/*synchronized (this) {
System.out.println("我是对象锁代码块,我叫"+Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+"玩完了");
}*/
}
public static void main(String[] args) {
Thread t1 = new Thread(instance,"线程一");
Thread t2 = new Thread(instance,"线程二");
t1.start();
t2.start();
while(t1.isAlive()||t2.isAlive()) { }
System.out.println("执行结束");
}
}
/**
* 普通方法锁形式
* @author Administrator
*
*/
public class SynchronizeTest02 implements Runnable{
static SynchronizeTest02 instance = new SynchronizeTest02();
@Override
public void run() {
//调用加synchronized关键字的普通方法
method();
}
public synchronized void method() {
System.out.println("我是普通方法锁,我叫" + Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "玩完了");
}
public static void main(String[] args) {
Thread t1 = new Thread(instance,"线程一");
Thread t2 = new Thread(instance,"线程二");
t1.start();
t2.start();
while(t1.isAlive()||t2.isAlive()) { }
System.out.println("执行结束");
}
}
普通方法锁形式
类锁：每个类可能会有多个对象，但是每个类只有一个Class对象，所以类锁的本质就是对Class对象的锁，类锁在同一时刻只能被一个对象拥有（对象锁不可以）
类锁的第一种形式：在静态方法上加锁，并创建了两个对象，依然可以解决并发问题。
/**
*
* 类锁的第一种形式：静态方法锁形式
* @author Administrator
*
*/
public class SynchronizeTest02 implements Runnable{
static SynchronizeTest02 instance1 = new SynchronizeTest02();
static SynchronizeTest02 instance2 = new SynchronizeTest02();
@Override
public void run() {
//调用加synchronized关键字的静态方法
method();
}
public static synchronized void method() {
System.out.println("我是静态方法锁,我叫" + Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "玩完了");
}
public static void main(String[] args) {
Thread t1 = new Thread(instance1,"线程一");
Thread t2 = new Thread(instance2,"线程二");
t1.start();
t2.start();
while(t1.isAlive()||t2.isAlive()) { }
System.out.println("执行结束");
}
}
类锁的第二种形式：
/**
*
* 类锁的第二种形式：代码块锁.Class形式
* @author Administrator
*
*/
public class SynchronizeTest03 implements Runnable{
static SynchronizeTest03 instance1 = new SynchronizeTest03();
static SynchronizeTest03 instance2 = new SynchronizeTest03();
@Override
public void run() {
//调用加synchronized关键字的普通方法
method();
}
public void method() {
synchronized (SynchronizeTest03.class) {
System.out.println("我是静态方法锁,我叫" + Thread.currentThread().getName());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName() + "玩完了");
}
}
public static void main(String[] args) {
Thread t1 = new Thread(instance1,"线程一");
Thread t2 = new Thread(instance1,"线程二");
t1.start();
t2.start();
while(t1.isAlive()||t2.isAlive()) { }
System.out.println("执行结束");
}
}
