Java提供了一种内置的锁机制来支持原子性
每一个Java对象都可以用作一个实现同步的锁，称为内置锁，线程进入同步代码块之前自动获取到锁，代码块执行完成正常退出或代码块中抛出异常退出时会释放掉锁
内置锁为互斥锁，即线程A获取到锁后，线程B阻塞直到线程A释放锁，线程B才能获取到同一个锁
内置锁使用synchronized关键字实现，synchronized关键字有两种用法：
1，修饰需要进行同步的方法（所有访问状态变量的方法都必须进行同步），此时充当锁的对象为调用同步方法的对象
public class Test{
private int count = 0;
public synchronized int add(){
count += 1;
return count;
}
public synchronized int delete(){
count -= 1;
return count;
}
}2，同步代码块
和直接使用synchronized修饰需要同步的方法是一样的，但是锁的粒度可以更细，并且充当锁的对象不一定是this，也可以是其它对象，所以使用起来更加灵活
public class Test{
private int count = 0;
public int add(){
synchronized(this){
count += 1;
}
return count;
}
public int delete(){
synchronized(this){
count -= 1;
}
return count;
}
}用synchronized关键字修饰的方法可以认为是一个横跨整个方法体的同步代码块
public class Status {
private int num = 0;
public void selfIncrease(){
num = num + 1;
System.out.println(Thread.currentThread().getName()
+ "|" + num);
}
}public class Task implements Runnable {
private Status status;
public Task(Status status){
this.status = status;
}
public void run() {
synchronized (status) {
status.selfIncrease();
}
}
public static void main(String[] args) {
Status status = new Status();
Task task = new Task(status);
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
Thread t3 = new Thread(task);
Thread t4 = new Thread(task);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
运行结果为：
Thread-0|1
Thread-3|2
Thread-2|3
Thread-1|4
修改上面的代码，每个线程运行时创建一个新的Status对象，而不是像上面的代码，4个线程共用同一个Status对象：
public class Task implements Runnable {
public void run() {
Status status = new Status();
synchronized (status) {
status.selfIncrease();
}
}
public static void main(String[] args) {
Task task = new Task();
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
Thread t3 = new Thread(task);
Thread t4 = new Thread(task);
t1.start();
t2.start();
t3.start();
t4.start();
}
}由于充当锁的对象实例不一定是同一个对象（hashcode不同），同步失效：
Thread-0|1
Thread-1|1
Thread-3|1
Thread-2|1
因此同步代码块中充当锁的对象必须为同一个对象
public class Task implements Runnable {
private Status status;
public Task(Status status){
this.status = status;
}
public void run() {
synchronized (status) {
System.out.println("Thread lock");
System.out.println("Thread:" + status.getNum());
System.out.println("Thread over");
}
}
public static void main(String[] args) {
Status status = new Status();
Task task = new Task(status);
Thread t = new Thread(task);
t.start();
//synchronized(status){
System.out.println("Main");
status.setNum(1);
System.out.println("Main:" + status.getNum());
//}
}
}运行结果为：
Main
Thread lock
Main:1
Thread:1
Thread over从运行结果可以看出，在Thread线程锁定status对象的时候，Main线程在Thread线程释放锁对象前依然能够修改status对象的num域，说明锁没有生效
Main线程中没有对status对象进行同步，故在Thread线程锁定status对象的时候不需要阻塞，可以直接操作status对象，因此所有使用同步对象的地方都必须进行同步
修改方式为：Task类的main方法中，在操作status对象时进行同步（去掉代码中的注释部分）
如果锁对象为静态变量，或使用synchronized关键字修饰静态方法，则锁对象为Class对象
public class Status {
private static int num = 0;
public synchronized static void selfIncrease(){
num = num + 1;
System.out.println(Thread.currentThread().getName()
+ "|" + num);
}
}public class Task implements Runnable {
public void run() {
Status.selfIncrease();
}
public static void main(String[] args) throws Exception {
Task task = new Task();
Thread t1 = new Thread(task);
Thread t2 = new Thread(task);
Thread t3 = new Thread(task);
Thread t4 = new Thread(task);
t1.start();
t2.start();
t3.start();
t4.start();
}
}运行结果如下：
Thread-0|1
Thread-1|2
Thread-3|3
Thread-2|4
相当于：
public class Status {
private static int num = 0;
public static void selfIncrease(){
synchronized(Status.class){
num = num + 1;
System.out.println(Thread.currentThread().getName()
+ "|" + num);
}
}
}
或是：
public class Status {
private static int num = 0;
private static Object lock = new Object();
public static void selfIncrease(){
synchronized(lock){
num = num + 1;
System.out.println(Thread.currentThread().getName()
+ "|" + num);
}
}
}
