一、java多線程基本入門
java多線程編程還是比較重要的，在實際業務開發中經常要遇到這個問題。 java多線程，傳統創建線程的方式有兩種。 1、繼承自Thread類，覆寫run方法。 2、實現Runnable接口，實現run方法。 啟動線程的方法都是調用start方法，真正執行調用的是run方法。
參考代碼如下：
代碼如下：
package com.jack.thread;
/**
* 線程簡單演示例子程序
*
* @author pinefantasy
* @since 2013-10-31
*/
public class ThreadDemo1 {
/**
* 第一種方式：繼承自Thread類，覆寫run方法
*/
public static class Test1Thread extends Thread {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Test1," + Thread.currentThread().getName() + ", i = " + i);
}
}
}
/**
* 第二種方式：實現Runnable接口，實現run方法
*/
public static class Test2Thread implements Runnable {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Test2," + Thread.currentThread().getName() + ", i = " + i);
}
}
}
/**
* <pre>
*
* 主線程為main線程
* 分支線程為：1 2 3 三種簡單實現方式
*
* @param args
*/
public static void main(String[] args) {
new Test1Thread().start();// 啟動線程1
new Thread(new Test2Thread()).start();// 啟動線程2
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 0; i < 100; i++) {
System.out.println("Test3," + Thread.currentThread().getName() + ", i = " + i);
}
}
}).start();// 啟動線程3
}
}
二、java並發包簡單入門
多個線程，統一處理同一個變量演示代碼：
代碼如下：
package com.jack.thread;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 多線程對同一個變量進行操作
*
* @author pinefantasy
* @since 2013-10-31
*/
public class ThreadDemo2 {
private static int count = 0;
public static class CountThread implements Runnable {// 1.這邊有線程安全問題，共享變量亂套了
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
count++;
System.out.println(Thread.currentThread().getName() + ", count = " + count);
}
}
}
private static final Object lock = new Object();// 這邊使用的lock對象
public static class Count2Thread implements Runnable {// 這邊使用的是互斥鎖方式
@Override
public void run() {
synchronized (lock) {// 使用互斥鎖方式處理
for (int i = 0; i < 100; i++) {
count++;
System.out.println(Thread.currentThread().getName() + ", count = " + count);
}
}
}
}
private static AtomicInteger ai = new AtomicInteger();// 這邊使用的是並發包的AtomicXXX類，使用的是CAS方式：compare and swap
public static class Count3Thread implements Runnable {// AtomicInteger內部的CAS實現方式，采用的是：循環、判斷、設置三部曲方式
@Override
public void run() {
for (int i = 0; i < 100; i++) {
int tmp = ai.incrementAndGet();// 采用CAS方式處理
System.out.println(Thread.currentThread().getName() + ", count = " + tmp);
}
}
}
private static volatile int countV = 0;// 定義成volatile，讓多線程感知，因為值是放在主存中
public static class Count4Thread implements Runnable {// volatile定義的變量只是說放到了主存，當時++操作並不是原子操作，這個要小心
@Override
public void run() {
for (int i = 0; i < 100; i++) {
try {
Thread.sleep(50);// 這邊讓線程休眠下，增加出錯概率
} catch (InterruptedException e) {
e.printStackTrace();
}
countV++;// volatile要正確使用，不是說定義成volatile就是安全的，還是要注意++ --操作並不是原子操作
System.out.println(Thread.currentThread().getName() + ", count = " + countV);
}
}
}
/**
* 使用泛型簡單編寫一個測試方法
*
* @param <T>
* @param t
* @throws InstantiationException
* @throws IllegalAccessException
* @throws InterruptedException
*/
public static <T> void testTemplate(T t) throws InstantiationException, IllegalAccessException, InterruptedException {
for (int i = 0; i < 5; i++) {
if (t instanceof Runnable) {
Class<?> c = t.getClass();
Object object = c.newInstance();
new Thread((Runnable) object).start();
}
}
}
/**
* <pre>
* 1.test1 線程不安全演示例子，count變量不能得到預期的效果
* 2.test2 在test1基礎上改進的，用互斥鎖sync處理
* 3.test3 在test1基礎上改進的，用AtomicInteger類來實現
* 4.test4 有問題的方法，因為i++並不是原子操作，將count定義為volatile類型的
*
* @param args
* @throws InterruptedException
* @throws IllegalAccessException
* @throws InstantiationException
*/
public static void main(String[] args) throws InterruptedException, InstantiationException, IllegalAccessException {
// 1.測試1
// testTemplate(new CountThread());
// 2.測試2
// testTemplate(new Count2Thread());
// 3.測試3
// testTemplate(new Count3Thread());
// 4.測試4
testTemplate(new Count4Thread());
Thread.sleep(15000);
System.out.println(count);
System.out.println(ai.get());
System.out.println(countV);
}
}
生產者-消費者模式
生產者（生成產品的線程）--》負責生成產品 消費者（消費產品的線程）--》負責消費產品
買車人、消費者。 賣車人、銷售汽車的人、姑且當做生產者。 倉庫、存放汽車的地方。 汽車工廠、真實生成汽車的地方。
參考代碼如下：
// 沒有加上同步機制的代碼如下：
代碼如下：
package com.jack.thread;
import java.util.ArrayList;
import java.util.List;
import com.jack.thread.ThreadDemo3.CarBigHouse.Car;
/**
* 第一個版本的生產者和消費者線程
*
* @author pinefantasy
* @since 2013-11-1
*/
public class ThreadDemo3 {
/**
* 姑且賣車的當做是生產者線程
*/
public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
@Override
public void run() {
for (int i = 0; i < 100; 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;
}
@Override
public void run() {
for (int i = 0; i < 100; 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();
}
}
// 加上互斥鎖的代碼如下：
代碼如下：
package com.jack.thread;
import java.util.ArrayList;
import java.util.List;
import com.jack.thread.ThreadDemo4.CarBigHouse.Car;
/**
* 第二個版本的生產者消費者線程
*
* @author pinefantasy
* @since 2013-11-1
*/
public class ThreadDemo4 {
/**
* 姑且賣車的當做是生產者線程
*/
public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
@Override
public void run() {
for (int i = 0; i < 100; 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;
}
@Override
public void run() {
for (int i = 0; i < 100; 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;
}
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();
}
}
/ 采用Object類的wait和notify方法或者notifyAll方法（注意notify方法和notifyAll方法區別） // notify是喚醒其中一個在等待的線程。 // notifyAll是喚醒其他全部在等待的線程，但是至於哪個線程可以獲得到鎖還是要看競爭關系。
線程狀態：創建、運行、阻塞、銷毀狀態。（阻塞情況比較多，比如等待數據IO輸入，阻塞了。）
代碼如下：
package com.jack.thread;
import java.util.ArrayList;
import java.util.List;
import com.jack.thread.ThreadDemo4.CarBigHouse.Car;
/**
* 第二個版本的生產者消費者線程
*
* @author pinefantasy
* @since 2013-11-1
*/
public class ThreadDemo4 {
/**
* 姑且賣車的當做是生產者線程
*/
public static class CarSeller implements Runnable {
private CarBigHouse bigHouse;
public CarSeller(CarBigHouse bigHouse) {
this.bigHouse = bigHouse;
}
@Override
public void run() {
for (int i = 0; i < 100; 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;
}
@Override
public void run() {
for (int i = 0; i < 100; 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 = 100;// 簡單設置下，做下上限設置
private Object lock = new Object();// 采用object的wait和notify方式處理同步問題
public int put() {// 提供給生產者放汽車到倉庫的接口
synchronized (lock) {
if (carList.size() == max) {// 達到了上限，不再生產car
try {
lock.wait();// 進行阻塞處理
} 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();
} 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();
}
}
