java多線程和并發(fā)包入門示例
一、java多線程基本入門
java多線程編程還是比較重要的，在實際業(yè)務(wù)開發(fā)中經(jīng)常要遇到這個問題。 java多線程，傳統(tǒng)創(chuàng)建線程的方式有兩種。 1、繼承自Thread類，覆寫run方法。 2、實現(xiàn)Runnable接口，實現(xiàn)run方法。 啟動線程的方法都是調(diào)用start方法，真正執(zhí)行調(diào)用的是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);
}
}
}
/**
* 第二種方式：實現(xiàn)Runnable接口，實現(xiàn)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 三種簡單實現(xiàn)方式
*
* @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并發(fā)包簡單入門
多個線程，統(tǒng)一處理同一個變量演示代碼：
package com.jack.thread;
import java.util.concurrent.atomic.AtomicInteger;
/**
* 多線程對同一個變量進(jìn)行操作
*
* @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();// 這邊使用的是并發(fā)包的AtomicXXX類，使用的是CAS方式：compare and swap
public static class Count3Thread implements Runnable {// AtomicInteger內(nèi)部的CAS實現(xiàn)方式，采用的是：循環(huán)、判斷、設(shè)置三部曲方式
@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定義的變量只是說放到了主存，當(dāng)時++操作并不是原子操作，這個要小心
@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變量不能得到預(yù)期的效果
* 2.test2 在test1基礎(chǔ)上改進(jìn)的，用互斥鎖sync處理
* 3.test3 在test1基礎(chǔ)上改進(jìn)的，用AtomicInteger類來實現(xiàn)
* 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);
}
}
生產(chǎn)者-消費者模式
生產(chǎn)者（生成產(chǎn)品的線程）--》負(fù)責(zé)生成產(chǎn)品 消費者（消費產(chǎn)品的線程）--》負(fù)責(zé)消費產(chǎn)品
買車人、消費者。 賣車人、銷售汽車的人、姑且當(dāng)做生產(chǎn)者。 倉庫、存放汽車的地方。 汽車工廠、真實生成汽車的地方。
參考代碼如下：
// 沒有加上同步機(jī)制的代碼如下：
package com.jack.thread;
import java.util.ArrayList;
import java.util.List;
import com.jack.thread.ThreadDemo3.CarBigHouse.Car;
/**
* 第一個版本的生產(chǎn)者和消費者線程
*
* @author pinefantasy
* @since 2013-11-1
*/
public class ThreadDemo3 {
/**
* 姑且賣車的當(dāng)做是生產(chǎn)者線程
*/
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++) {// 當(dāng)做生產(chǎn)者線程，往倉庫里邊增加汽車，其實是觸發(fā)增加汽車
int count = bigHouse.put();
System.out.println("生產(chǎn)汽車-->count = " + count);
}
}
}
/**
* 姑且買車的人當(dāng)做是消費者線程
*/
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++) {// 當(dāng)做消費者線程，從倉庫里邊提取汽車，其實是觸發(fā)，從倉庫里邊提取一輛汽車出來
int count = bigHouse.get();
System.out.println("消費汽車-->count = " + count);
}
}
}
/**
* 這邊姑且當(dāng)做是車子big house放車子的倉庫房
*/
public static class CarBigHouse {
public int carNums = 0;// 這邊是倉庫房子中車子的數(shù)量總數(shù)
public List<Car> carList = new ArrayList<Car>();// 這邊模擬用來放汽車的list
public int put() {// 提供給生產(chǎn)者放汽車到倉庫的接口
Car car = CarFactory.makeNewCar();
carList.add(car);// 加到倉庫中去
carNums++;// 總數(shù)增加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--;// 總數(shù)減少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;
}
}
}
/**
* 采用靜態(tài)工廠方式創(chuàng)建car對象，這個只是簡單模擬，不做設(shè)計模式上的過多考究
*/
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();
}
}
/**
* 第一個版本的生產(chǎn)者和消費者線程，沒有加上同步機(jī)制的演示例子
*
* @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;
/**
* 第二個版本的生產(chǎn)者消費者線程
*
* @author pinefantasy
* @since 2013-11-1
*/
public class ThreadDemo4 {
/**
* 姑且賣車的當(dāng)做是生產(chǎn)者線程
*/
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++) {// 當(dāng)做生產(chǎn)者線程，往倉庫里邊增加汽車，其實是觸發(fā)增加汽車
int count = bigHouse.put();
System.out.println("生產(chǎn)汽車-->count = " + count);
}
}
}
/**
* 姑且買車的人當(dāng)做是消費者線程
*/
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++) {// 當(dāng)做消費者線程，從倉庫里邊提取汽車，其實是觸發(fā)，從倉庫里邊提取一輛汽車出來
int count = bigHouse.get();
System.out.println("消費汽車-->count = " + count);
}
}
}
/**
* 這邊姑且當(dāng)做是車子big house放車子的倉庫房
*/
public static class CarBigHouse {
public int carNums = 0;// 這邊是倉庫房子中車子的數(shù)量總數(shù)
public List<Car> carList = new ArrayList<Car>();// 這邊模擬用來放汽車的list
// 直接增加上synchronized關(guān)鍵字方式，成員方法，鎖的是當(dāng)前bigHouse對象
// 這種鎖是互斥鎖，方法在同一個時刻，只有一個線程可以訪問到里邊的代碼
public synchronized int put() {// 提供給生產(chǎn)者放汽車到倉庫的接口
Car car = CarFactory.makeNewCar();
carList.add(car);// 加到倉庫中去
carNums++;// 總數(shù)增加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--;// 總數(shù)減少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;
}
}
}
/**
* 采用靜態(tài)工廠方式創(chuàng)建car對象，這個只是簡單模擬，不做設(shè)計模式上的過多考究
*/
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();
}
}
/**
* 第二個版本的生產(chǎn)者和消費者線程，加上了同步機(jī)制的方法
*
* @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方法區(qū)別） // notify是喚醒其中一個在等待的線程。 // notifyAll是喚醒其他全部在等待的線程，但是至于哪個線程可以獲得到鎖還是要看競爭關(guān)系。
線程狀態(tài)：創(chuàng)建、運行、阻塞、銷毀狀態(tài)。（阻塞情況比較多，比如等待數(shù)據(jù)IO輸入，阻塞了。）
package com.jack.thread;
import java.util.ArrayList;
import java.util.List;
import com.jack.thread.ThreadDemo4.CarBigHouse.Car;
/**
* 第二個版本的生產(chǎn)者消費者線程
*
* @author pinefantasy
* @since 2013-11-1
*/
public class ThreadDemo4 {
/**
* 姑且賣車的當(dāng)做是生產(chǎn)者線程
*/
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++) {// 當(dāng)做生產(chǎn)者線程，往倉庫里邊增加汽車，其實是觸發(fā)增加汽車
int count = bigHouse.put();
System.out.println("生產(chǎn)汽車-->count = " + count);
}
}
}
/**
* 姑且買車的人當(dāng)做是消費者線程
*/
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++) {// 當(dāng)做消費者線程，從倉庫里邊提取汽車，其實是觸發(fā)，從倉庫里邊提取一輛汽車出來
int count = bigHouse.get();
System.out.println("消費汽車-->count = " + count);
}
}
}
/**
* 這邊姑且當(dāng)做是車子big house放車子的倉庫房
*/
public static class CarBigHouse {
public int carNums = 0;// 這邊是倉庫房子中車子的數(shù)量總數(shù)
public List<Car> carList = new ArrayList<Car>();// 這邊模擬用來放汽車的list
public static final int max = 100;// 簡單設(shè)置下，做下上限設(shè)置
private Object lock = new Object();// 采用object的wait和notify方式處理同步問題
public int put() {// 提供給生產(chǎn)者放汽車到倉庫的接口
synchronized (lock) {
if (carList.size() == max) {// 達(dá)到了上限，不再生產(chǎn)car
try {
lock.wait();// 進(jìn)行阻塞處理
} catch (InterruptedException e) {
e.printStackTrace();
}
}
Car car = CarFactory.makeNewCar();
carList.add(car);// 加到倉庫中去
carNums++;// 總數(shù)增加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--;// 總數(shù)減少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;
}
}
}
/**
* 采用靜態(tài)工廠方式創(chuàng)建car對象，這個只是簡單模擬，不做設(shè)計模式上的過多考究
*/
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();
}
}
/**
* 第二個版本的生產(chǎn)者和消費者線程，加上了同步機(jī)制的方法
*
* @param args
*/
public static void main(String[] args) {
CarBigHouse bigHouse = new CarBigHouse();
new Thread(new CarSeller(bigHouse)).start();
new Thread(new Consumer(bigHouse)).start();
}
}
相關(guān)文章
Struts2學(xué)習(xí)筆記(5)-參數(shù)傳遞方法
本文主要介紹Struts2中參數(shù)傳遞方法，希望能給大家做一個參考。2016-06-06
大伙們有沒有遇到數(shù)據(jù)亂碼的問題，真的是讓人心情煩躁，今天就來教下大家數(shù)據(jù)怎么傳輸?shù)角岸艘约皝y碼問題怎么解決的，需要的朋友可以參考一下2021-12-12
這篇文章主要主要介紹了Java虛擬機(jī)（JVM）的有關(guān)內(nèi)容以及Java程序的運行機(jī)制和錯誤分析，需要的朋友可以了解下。2017-09-09
Dubbo是一個分布式服務(wù)框架，致力于提供高性能和透明化的RPC遠(yuǎn)程服務(wù)調(diào)用方案，以及SOA服務(wù)治理方案，這篇文章主要介紹了dubbo詳解及demo實例,需要的朋友可以參考下2022-04-04
這篇文章主要為大家詳細(xì)介紹了JAVA提高第九篇集合體系的相關(guān)資料，具有一定的參考價值，感興趣的小伙伴們可以參考一下2017-10-10
這篇文章主要介紹了舉例說明Java中代碼塊的執(zhí)行順序,需要的朋友可以參考下2017-04-04
淺談spring使用策略模式實現(xiàn)多種場景登錄方式
本文主要介紹了spring使用策略模式實現(xiàn)多種場景登錄方式，文中通過示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-12-12
Spring?boot事務(wù)無效報錯:Transaction?not?enabled問題排查解決
在業(yè)務(wù)代碼中經(jīng)常需要保證事務(wù)的原子性,但是有的時候確實是出現(xiàn)事務(wù)沒有生效,這篇文章主要給大家介紹了關(guān)于Spring?boot事務(wù)無效報錯:Transaction?not?enabled問題排查的相關(guān)資料,需要的朋友可以參考下2023-11-11
關(guān)于Mybatis動態(tài)sql中test的坑點總結(jié)
這篇文章主要介紹了關(guān)于Mybatis動態(tài)sql中test的坑點，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2022-01-01
關(guān)于IDEA 2020.3 多窗口視圖丟失的問題
這篇文章主要介紹了關(guān)于IDEA 2020.3 多窗口視圖丟失的問題,本文給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值，需要的朋友可以參考下2020-12-12