第二章 Basic Thread Synchronization (基础线程同步) 【上】

涉及的内容

同步一个方法
同步类中分配一个独立属性
在同步代码中使用条件
使用Lock锁定代码块
同步数据的读写锁
修改Lock公平模式
在Lock中使用多条件

简介

同步类似就是车过收费站，一杆一车，排队出收费站，不许并行。

对于同步的代码块称为critical section (临界断面)

为了实现这个同步将会介绍两种同步方法：

关键字：synchronized
Lock的接口和它的实现类

1、同步方法（synchronized）

注意：对于一个类有个static的同步方法和非static方法，两个线程可以同时进入同一对象不同方法，如果同时修改同一个数据，将会产生数据不一致。

例子：模拟取存款过程

public class Account {
private double balance;

public double getBalance() {
return balance;
}

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

public synchronized void addAmount(double amount){
System.out.printf("增加了金额++++++：%f\n", amount);
double tmp = balance;
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
tmp += amount;
balance=tmp;
}

public synchronized void substractAmount(double amount){
System.out.printf("减少了金额------：%f\n", amount);
double tmp = balance;
try {
Thread.sleep(10);
} catch (InterruptedException e){
e.printStackTrace();
}
tmp -= amount;
balance = tmp;
}

}

public class Bank implements Runnable{

private Account account;

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

@Override
public void run() {
for (int i=0; i< 10; i++){
account.substractAmount(1000);
}
}

}

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<10; i++){
account.addAmount(1000);
}
}

}

public class Main {
public static void main(String[] args){
Account account = new Account();
account.setBalance(1000);
Company company = new Company(account);
Thread companyThread = new Thread(company);
Bank bank = new Bank(account);
Thread bankThread = new Thread(bank);

System.out.printf("账户：初始化金额： %f\n", account.getBalance());
companyThread.start();
bankThread.start();
try{
companyThread.join();
bankThread.join();
System.out.printf("账户：最终金额：%f\n", account.getBalance());
} catch (InterruptedException e){
e.printStackTrace();
}
}
}

日志：



总结：

1、synchronized进行同步操作保证最后的结果是准确的。
2、你可以删除synchronized测试结果。

2、在同步类分配独立属性

模拟电影院两个放映室和两个购票处

public class Cinema {
private long vacanciesCinema1;
private long vacanciesCinema2;

private final Object controlCinema1, controlCinema2;

/**
* 初始20张票
*/
public Cinema(){
controlCinema1 = new Object();
controlCinema2 = new Object();
vacanciesCinema1 = 20;
vacanciesCinema2 = 20;
}

/**
* 售票
* @param number
* @return
*/
public boolean sellTickets1(int number){
synchronized (controlCinema1){
if(number < vacanciesCinema1){
vacanciesCinema1 -= number;
return true;
} else {
return false;
}
}
}

/**售票
* @param number
* @return
*/
public boolean sellTickets2 (int number){
synchronized (controlCinema2){
if(number < vacanciesCinema2){
vacanciesCinema2 -= number;
return true;
} else {
return false;
}
}
}

/**
* 退票
* @param number
* @return
*/
public boolean returnTicket1 (int number){
synchronized (controlCinema1){
vacanciesCinema1 += number;
return true;
}
}
/**
* 退票
* @param number
* @return
*/
public boolean returnTicket2 (int number){
synchronized (controlCinema2){
vacanciesCinema2 += number;
return true;
}
}

/**
* 返回余票
* @return
*/
public long getVacanciesCinema1(){
return vacanciesCinema1;
}

/**
* 返回余票
* @return
*/
public long getVacanciesCinema2(){
return vacanciesCinema2;
}
}

public class TicketOffice1 implements Runnable{

private Cinema cinema;

public TicketOffice1(Cinema cinema) {
super();
this.cinema = cinema;
}

@Override
public void run() {
cinema.sellTickets1(3);
cinema.sellTickets1(2);
cinema.sellTickets2(2);
cinema.returnTicket1(3);
/*cinema.sellTickets1(5);
cinema.sellTickets2(2);
cinema.sellTickets2(2);
cinema.sellTickets2(2);*/
}

}

public class TicketOffice2 implements Runnable{

private Cinema cinema;

public TicketOffice2(Cinema cinema) {
super();
this.cinema = cinema;
}

@Override
public void run() {
cinema.sellTickets2(3);
cinema.sellTickets2(4);
/*cinema.sellTickets1(2);
cinema.sellTickets1(1);
cinema.returnTicket2(2);
cinema.sellTickets1(3);
cinema.sellTickets2(2);
cinema.sellTickets1(2);*/
}

}

public class Main {
public static void main(String[] args){
Cinema cinema = new Cinema();
TicketOffice1 ticketOffice1 = new TicketOffice1(cinema);
Thread thread1 = new Thread(ticketOffice1, "TicketOffice1");
TicketOffice2 ticketOffice2 = new TicketOffice2(cinema);
Thread thread2 = new Thread(ticketOffice2, "TicketOffice2");

thread1.start();
thread2.start();

try{
thread1.join();
thread2.join();

}catch (InterruptedException e){
e.printStackTrace();
}
System.out.printf("放映室1空闲的数量：%d\n", cinema.getVacanciesCinema1());
System.out.printf("放映室2空闲的数量：%d\n", cinema.getVacanciesCinema2());
}
}

总结：
1、创建的controlCinema1和controlCinema2并没有实际的作用，它只是作为关联锁定花括号的代码，

（说白了就是如果锁定controlCinema2代码中所有对象，每次只一个线程访问这些对象）。

3、在同步代码中使用条件

生产者-消费者模型（wait() notify() notifyAll()）

package com.jack;

import java.util.Date;
import java.util.LinkedList;
import java.util.List;

public class EventStorage {
private int maxSize;
private List<Date> storage;

public EventStorage(){
maxSize=10;
storage=new LinkedList<>();
}

public synchronized void set(){
while (storage.size()==maxSize){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
storage.add(new Date());
System.out.printf("++当然前仓库: %d\n",storage.size());
notifyAll();
}

public synchronized void get(){
while (storage.size()==0){
try {
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.printf("--当然前仓库: %d: %s\n",storage.
size(),((LinkedList<?>)storage).poll());
notifyAll();
}
}

package com.jack;

public class Producer implements Runnable{

private EventStorage storage;

public Producer(EventStorage storage) {
super();
this.storage = storage;
}

@Override
public void run() {
for (int i=0; i <100; i++){
storage.set();
}
}

}

package com.jack;

public class Consumer implements Runnable{
private EventStorage storage;

public Consumer(EventStorage storage) {
super();
this.storage = storage;
}

@Override
public void run() {
for (int i=0; i<100; i++){
storage.get();
}
}

}

package com.jack;

public class Main {
public static void main(String[] args){
EventStorage storage = new EventStorage();
Producer producer = new Producer(storage);
Thread thread1 = new Thread(producer);

Consumer consumer = new Consumer(storage);
Thread thread2 = new Thread(consumer);

thread2.start();
thread1.start();

}
}

总结：

1、创建一个仓库类，有添加和删除，创建生产线程和消费线程。当等于10时候等待，唤醒对方。
2、wait等待，notifyAll()唤醒所有线程

4、采用Lock锁定同步块

Lock优点（ReentrantLock）

1、允许同步块更加灵活。
2、Lock接口比synchronized提供额外的功能，增加tryLock()返回同步块的状态
3、Lock允许读写分离
4、Lock性能比synchronized关键字更优。

例子：使用Lock同步代码块模拟打印队列

package com.jack;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class PrintQueue {
private final Lock queueLock = new ReentrantLock();

public void printJob(Object document){
queueLock.lock();
try {
Long duration = (long) (Math.random()*10000);
System.out.printf(Thread.currentThread().getName()
+ "：打印队列：打印一个工作持续时间 %s ",(duration/1000)
+ " seconds");
Thread.sleep(duration);
} catch (InterruptedException e){
e.printStackTrace();
}finally{
queueLock.unlock();
}
}
}

package com.jack;

public class Job implements Runnable{

private PrintQueue printQueue;

public Job(PrintQueue printQueue) {
super();
this.printQueue = printQueue;
}

@Override
public void run() {
System.out.printf("%s：去打印一个文档\n", Thread.currentThread().getName());
printQueue.printJob(new Object());
System.out.printf("%s: 这个文档已经打印了\n", Thread.currentThread().getName());
}

}

package com.jack;

public class Main {
public static void main(String[] args){
PrintQueue printQueue = new PrintQueue();
Thread thread[] = new Thread[10];
for (int i=0; i<10; i++){
thread[i]= new Thread(new Job(printQueue), "线程  " + i);
}

for(int i=0; i<10; i++){
thread[i].start();
}
}
}

总结：

1、private final Lock queueLock = new ReentrantLock(); 是关键。首先为该类配一个锁
2、lock()方法锁定的意思，第一个进来之后锁住，直到执行完，（类似卵子受精就是这个例子）
3、ReentrantLock允许递归调用
4、注意避免死锁