java多線程簡單demo
1.沒有加上同步機制
import java.util.ArrayList;
import java.util.List;
import com.yingze.thread.ThreadDemo1.CarBigHouse.Car;
/**
* @ClassName: ThreadDemo1
* @Description: TODO(沒有加上同步機制)
* @author liang
* @date 2016年4月29日 上午11:28:43
*
*/
public class ThreadDemo1 {
/**
* 姑且賣車的當做是生産者線程
*/
public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
public void run() {
for (int i = 0; i < 10; i++) {// 當做生産者線程,往倉庫裡邊增加汽車,其實是觸發增加汽車
int count = bigHouse.put();
System.out.println("生産汽車-->count = " + count);
}
}
}
/**
* 姑且買車的人當做是消費者線程
*/
public static class Consumer implements Runnable {
private CarBigHouse bigHouse;
public Consumer(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
public void run() {
for (int i = 0; i < 10; i++) {// 當做消費者線程,從倉庫裡邊提取汽車,其實是觸發,從倉庫裡邊提取一輛汽車出來
int count = bigHouse.get();
System.out.println("消費汽車-->count = " + count);
}
}
}
/**
* 這邊姑且當做是車子big house放車子的倉庫房
*/
public static class CarBigHouse {
public int carNums = 0;// 這邊是倉庫房子中車子的數量總數
public List<Car> carList = new ArrayList<Car>();// 這邊模拟用來放汽車的list
public int put() {// 提供給生産者放汽車到倉庫的接口
Car car = CarFactory.makeNewCar();
carList.add(car);// 加到倉庫中去
carNums++;// 總數增加1
return carNums;
}
public int get() {// 提供給消費者從這邊取汽車接口
Car car = null;
if (carList.size() != 0) {// size不為空才去取車
car = carList.get(carList.size() - 1);// 提取最後一個car
carList.remove(car);// 從車庫list中移除掉
carNums--;// 總數減少1
}
return carNums;
}
public static class Car {
public String carName;// 汽車名稱
public double carPrice;// 汽車價格
public Car() {
}
public Car(String carName, double carPrice) {
this.carName = carName;
this.carPrice = carPrice;
}
}
}
/**
* 采用靜态工廠方式建立car對象,這個隻是簡單模拟,不做設計模式上的過多考究
*/
public static class CarFactory {
private CarFactory() {
}
public static Car makeNewCar(String carName, double carPrice) {
return new Car(carName, carPrice);
}
public static Car makeNewCar() {
return new Car();
}
}
/**
* 第一個版本的生産者和消費者線程,沒有加上同步機制的示範例子
*
* @param args
*/
public static void main(String[] args) {
CarBigHouse bigHouse = new CarBigHouse();
new Thread(new CarSeller(bigHouse)).start();
new Thread(new Consumer(bigHouse)).start();
}
}
2.加上互斥鎖
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;
import com.yingze.thread.ThreadDemo2.CarBigHouse.Car;
/**
* @ClassName: ThreadDemo2
* @Description: TODO(加上互斥鎖)
* @author liang
* @date 2016年4月29日 上午11:33:26
*
*/
public class ThreadDemo2 {
/**
* 姑且賣車的當做是生産者線程
*/
public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
public void run() {
for (int i = 0; i < 10; i++) {// 當做生産者線程,往倉庫裡邊增加汽車,其實是觸發增加汽車
int count = bigHouse.put();
System.out.println("生産汽車-->count = " + count);
}
}
}
/**
* 姑且買車的人當做是消費者線程
*/
public static class Consumer implements Runnable {
private CarBigHouse bigHouse;
public Consumer(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
public void run() {
for (int i = 0; i < 10; i++) {// 當做消費者線程,從倉庫裡邊提取汽車,其實是觸發,從倉庫裡邊提取一輛汽車出來
int count = bigHouse.get();
System.out.println("消費汽車-->count = " + count);
}
}
}
/**
* 這邊姑且當做是車子big house放車子的倉庫房
*/
public static class CarBigHouse {
public int carNums = 0;// 這邊是倉庫房子中車子的數量總數
public List<Car> carList = new ArrayList<Car>();// 這邊模拟用來放汽車的list
// 直接增加上synchronized關鍵字方式,成員方法,鎖的是目前bigHouse對象
// 這種鎖是互斥鎖,方法在同一個時刻,隻有一個線程可以通路到裡邊的代碼
/*public synchronized int put() {// 提供給生産者放汽車到倉庫的接口
Car car = CarFactory.makeNewCar();
carList.add(car);// 加到倉庫中去
carNums++;// 總數增加1
return carNums;
}
public synchronized int get() {// 提供給消費者從這邊取汽車接口
Car car = null;
if (carList.size() != 0) {// size不為空才去取車
car = carList.get(carList.size() - 1);// 提取最後一個car
carList.remove(car);// 從從庫list中移除掉
carNums--;// 總數減少1
}
return carNums;
}*/
//Lock提供了比synchronized方法和synchronized代碼塊更廣泛的鎖定操作,Lock更靈活的結構,有很大的差别,并且可以支援多個Condition對象 Lock是控制多個線程對共享資源進行通路的工具。通常,鎖提供了對共享資源的獨占通路,每次隻能有一個線程對Lock對象加鎖, 線程開始通路共享資源之前應先獲得Lock對象。不過某些鎖支援共享資源的并發通路,如:ReadWriteLock(讀寫鎖),線上程安全控制中, 通常使用ReentrantLock(可重入鎖)。使用該Lock對象可以顯示加鎖、釋放鎖。
final ReentrantLock lock=new ReentrantLock();
public int put() {// 提供給生産者放汽車到倉庫的接口
//上鎖
lock.lock();
try{
Car car = CarFactory.makeNewCar();
carList.add(car);// 加到倉庫中去
carNums++;// 總數增加1
}finally{
//釋放鎖
lock.unlock();
}
return carNums;
}
public int get() {// 提供給消費者從這邊取汽車接口
//上鎖
lock.lock();
try{
Car car = null;
if (carList.size() != 0) {// size不為空才去取車
car = carList.get(carList.size() - 1);// 提取最後一個car
carList.remove(car);// 從車庫list中移除掉
carNums--;// 總數減少1
}
}finally{
//釋放鎖
lock.unlock();
}
return carNums;
}
public static class Car {
public String carName;// 汽車名稱
public double carPrice;// 汽車價格
public Car() {
}
public Car(String carName, double carPrice) {
this.carName = carName;
this.carPrice = carPrice;
}
}
}
/**
* 采用靜态工廠方式建立car對象,這個隻是簡單模拟,不做設計模式上的過多考究
*/
public static class CarFactory {
private CarFactory() {
}
public static Car makeNewCar(String carName, double carPrice) {
return new Car(carName, carPrice);
}
public static Car makeNewCar() {
return new Car();
}
}
/**
* 第一個版本的生産者和消費者線程,沒有加上同步機制的示範例子
*
* @param args
*/
public static void main(String[] args) {
CarBigHouse bigHouse = new CarBigHouse();
new Thread(new CarSeller(bigHouse)).start();
new Thread(new Consumer(bigHouse)).start();
}
}
3.采用Object類的wait和notify方法或者notifyAll方法
import java.util.ArrayList;
import java.util.List;
import com.yingze.thread.ThreadDemo3.CarBigHouse.Car;
/**
* @ClassName: ThreadDemo3
* @Description: TODO(采用Object類的wait和notify方法或者notifyAll方法(注意notify方法和notifyAll方法差別) notify是喚醒其中一個在等待的線程。 notifyAll是喚醒其他全部在等待的線程,但是至于哪個線程可以獲得到鎖還是要看競争關系。線程狀态:建立、運作、阻塞、銷毀狀态。(阻塞情況比較多,比如等待資料IO輸入,阻塞了。))
* @author liang
* @date 2016年4月29日 上午11:38:09
*
*/
public class ThreadDemo3 {
/**
* 姑且賣車的當做是生産者線程
*/
public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
public void run() {
for (int i = 0; i < 10; i++) {// 當做生産者線程,往倉庫裡邊增加汽車,其實是觸發增加汽車
int count = bigHouse.put();
System.out.println("生産汽車-->count = " + count);
}
}
}
/**
* 姑且買車的人當做是消費者線程
*/
public static class Consumer implements Runnable {
private CarBigHouse bigHouse;
public Consumer(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
public void run() {
for (int i = 0; i < 10; i++) {// 當做消費者線程,從倉庫裡邊提取汽車,其實是觸發,從倉庫裡邊提取一輛汽車出來
int count = bigHouse.get();
System.out.println("消費汽車-->count = " + count);
}
}
}
/**
* 這邊姑且當做是車子big house放車子的倉庫房
*/
public static class CarBigHouse {
public int carNums = 0;// 這邊是倉庫房子中車子的數量總數
public List<Car> carList = new ArrayList<Car>();// 這邊模拟用來放汽車的list
public static final int max = 3;// 簡單設定下,做下上限設定
private Object lock = new Object();// 采用object的wait和notify方式處理同步問題
public int put() {// 提供給生産者放汽車到倉庫的接口
synchronized (lock) {
if (carList.size() == max) {// 達到了上限,不再生産car
try {
lock.wait();// 進行阻塞處理
System.out.println("生産達到上限...阻塞處理");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Car car = CarFactory.makeNewCar();
carList.add(car);// 加到倉庫中去
carNums++;// 總數增加1
lock.notify();// 喚醒等待的線程
return carNums;
}
}
public int get() {// 提供給消費者從這邊取汽車接口
Car car = null;
synchronized (lock) {
if (carList.size() == 0) {// 沒有汽車可以用來消費
try {
lock.wait();
System.out.println("沒有汽車...阻塞處理");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
if (carList.size() != 0) {// size不為空才去取車
car = carList.get(carList.size() - 1);// 提取最後一個car
carList.remove(car);// 從車庫list中移除掉
carNums--;// 總數減少1
}
lock.notify();
return carNums;
}
}
public static class Car {
public String carName;// 汽車名稱
public double carPrice;// 汽車價格
public Car() {
}
public Car(String carName, double carPrice) {
this.carName = carName;
this.carPrice = carPrice;
}
}
}
/**
* 采用靜态工廠方式建立car對象,這個隻是簡單模拟,不做設計模式上的過多考究
*/
public static class CarFactory {
private CarFactory() {
}
public static Car makeNewCar(String carName, double carPrice) {
return new Car(carName, carPrice);
}
public static Car makeNewCar() {
return new Car();
}
}
/**
* 第二個版本的生産者和消費者線程,加上了同步機制的方法
*
* @param args
*/
public static void main(String[] args) {
CarBigHouse bigHouse = new CarBigHouse();
new Thread(new CarSeller(bigHouse)).start();
new Thread(new Consumer(bigHouse)).start();
}
}