Java并发编程-06-Synchronize关键字同步机制

一、临界区 Critical Section

临界区是一个用以访问共享资源的代码块，这个代码块在同一时间内只允许一个线程执行

二、同步

1、当一个线程试图访问一个临界资源时，它将使用一种同步机制来查看是不是已经有其他的线程进入临界区

2、如果临界区没有其他线程，它就可以进入临界区。如果已经有线程进入临界区，它就被同步机制挂起，直到进入的线程离开这个临界区

3、如果在等待进入临界区的线程不止一个，jvm就会选择其中一个，其他的继续等待

三、java采用的两种基本的同步机制

synchronized关键字机制

Lock接口及其实现

四、synchronize关键字机制

synchronize修饰方法

1、使用synchronize关键字的方法性能比较低

2、每一个使用synchronize修饰的方法都是临界区

3、使用synchronize修饰的对象，那么同一时间只能有一个执行线程访问，如果其他线程试图访问这个对象的其他方法，都将被挂起

4、synchronize修饰静态方法会怎么样？

使用synchronize修饰的静态方法，那么同一时间只能有一个执行线程访问，但是其他线程可以访问这个对象的非静态方法。

synchronize修饰代码块

1、方法的其余部分保持在synchronize代码块之外，以获取更好的性能

2、synchronized修饰代码块的参数是当前对象，注意是对象，不是类

五、区别

1、java中每个对象都有同步锁，同步方法是指进入该方法时需要获取this对象的同步锁，而同步代码块则是可以指定需要获取哪个对象的同步锁

2、无论synchronized关键字加在方法上还是对象上，它取得的锁都是对象，而不是把一段代码或函数当作锁――同步方法很可能还会被其他线程的对象访问

六、测试同步方法

模拟场景：银行的账户，公司向账户转账，银行从账户扣除

package com.concurrent.threadSynchronize;

public class Account {

private double balance;

public double getBalance() {
return balance;
}

public void setBalance(double balance) {
this.balance = balance;
}

//向账户充值 amount
public synchronized void addAmount(double amount) {
double temp = balance;

try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}

temp += amount;
balance = temp;
}

//从账户取出amount
public synchronized void subtractAmount(double amount) {
double temp = balance;

try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
temp -= amount;
balance = temp;
}
}

package com.concurrent.threadSynchronize;

public class Bank implements Runnable{

private Account account;

public Bank(Account account) {
this.account = account;
}

//对账户进行扣除
@Override
public void run() {
for (int i = 0; i < 100; i++) {
account.subtractAmount(1000);
}
}
}

package com.concurrent.threadSynchronize;

public class Company implements Runnable {

private Account account;

public Company(Account account) {
super();
this.account = account;
}

// 向账户充值
@Override
public void run() {
for (int i = 0; i < 100; i++) {
account.addAmount(1000);
}
}
}

package com.concurrent.threadSynchronize;

public class Maintest {

public static void main(String[] args) {
Account account = new Account();
account.setBalance(1000);

Bank bank = new Bank(account);
Thread bankThread = new Thread(bank);

Company company = new Company(account);
Thread companyThread = new Thread(company);

System.out.println("Account initial : " + account.getBalance());

companyThread.start();
bankThread.start();

try {
companyThread.join();
bankThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("Account Final : " + account.getBalance());
}
}

七、测试同步代码块

模拟场景：电影院售票，有两个播放室，多个售票处，一张电影票只能去特定的播放室使用

package com.concurrent.threadSynchronize;

/**
* 有两个播放室和两个售票处的电影院 一个售票处卖出的票只能在一个特定的播放室使用
*
* @author Nicholas
*
*/
public class Cinema {
private long vacanciesCinama1; //票量
private long vacanciesCinama2;

private final Object controlCineme1; //播放室
private final Object controlCineme2;

public Cinema() {
controlCineme1 = new Object();
controlCineme2 = new Object();
vacanciesCinama1 = 20;
vacanciesCinama2 = 20;
}

public boolean sellTickets1(int number) {
synchronized (controlCineme1) {
if (number < vacanciesCinama1) {
vacanciesCinama1 -= number;
return true;
} else {
return false;
}
}
}

public boolean sellTickets2(int number) {
synchronized (controlCineme2) {
if (number < vacanciesCinama2) {
vacanciesCinama2 -= number;
return true;
} else {
return false;
}
}
}

// 退票
public boolean returnTickets1(int number) {
synchronized (controlCineme1) {
vacanciesCinama1 += number;
return true;
}
}

// 退票
public boolean returnTickets2(int number) {
synchronized (controlCineme2) {
vacanciesCinama2 += number;
return true;
}
}

public long getVacanciesCinama1() {
return vacanciesCinama1;
}

public void setVacanciesCinama1(long vacanciesCinama1) {
this.vacanciesCinama1 = vacanciesCinama1;
}

// 返回当前剩余的票数

public long getVacanciesCinama2() {
return vacanciesCinama2;
}

public void setVacanciesCinama2(long vacanciesCinama2) {
this.vacanciesCinama2 = vacanciesCinama2;
}
}

package com.concurrent.threadSynchronize;

/**
* 售票处一
*
* @author Nicholas
*
*/
public class TicketsOffice1 implements Runnable {

private Cinema cinema;

public TicketsOffice1(Cinema cinema) {
this.cinema = cinema;
}

@Override
public void run() {
cinema.sellTickets1(2);// 卖出的票是在第一个电影播放室的
cinema.sellTickets1(3);
cinema.sellTickets2(2);// 卖出的票是在第二个播放室使用的

cinema.returnTickets1(1);
cinema.returnTickets2(1);

cinema.sellTickets1(2);
cinema.sellTickets1(3);

cinema.sellTickets2(2);
cinema.sellTickets2(3);
}
}

package com.concurrent.threadSynchronize;

/**
* 售票处一
*
* @author Nicholas
*
*/
public class TicketsOffice2 implements Runnable {

private Cinema cinema;

public TicketsOffice2(Cinema cinema) {
this.cinema = cinema;
}

@Override
public void run() {
cinema.sellTickets1(2);// 卖出的票是在第一个电影播放室的
cinema.sellTickets1(3);
cinema.sellTickets2(2);// 卖出的票是在第二个播放室使用的

cinema.returnTickets1(1);
cinema.returnTickets2(1);

cinema.sellTickets1(2);
cinema.sellTickets1(3);

cinema.sellTickets2(2);
cinema.sellTickets2(3);
}
}

package com.concurrent.threadSynchronize;

public class MianTest1 {

public static void main(String[] args) {
Cinema cinema = new Cinema();

TicketsOffice1 ticketsOffice1 = new TicketsOffice1(cinema);
Thread ticketsOffice1Thread = new Thread(ticketsOffice1);

TicketsOffice2 ticketsOffice2 = new TicketsOffice2(cinema);
Thread ticketsOffice2Thread = new Thread(ticketsOffice2);

ticketsOffice1Thread.start();
ticketsOffice2Thread.start();

try {
ticketsOffice1Thread.join();
ticketsOffice2Thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}

System.out.println("Room 1 Vacancies : "+cinema.getVacanciesCinama1());
System.out.println("Room 2 Vacancies : "+cinema.getVacanciesCinama2());
}
}