java多線程和并發包入門示例

2019-11-26 15:53:54

字體：大中小

來源：轉載

供稿：網友

一、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;
        }

}

    /**
     * 姑且買車的人當做是消費者線程
     */
    public static class Consumer implements Runnable {

private CarBigHouse bigHouse;

        public Consumer(CarBigHouse bigHouse) {
            this.bigHouse = bigHouse;
        }

}

    /**
     * 這邊姑且當做是車子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;
        }

}

    /**
     * 姑且買車的人當做是消費者線程
     */
    public static class Consumer implements Runnable {

private CarBigHouse bigHouse;

        public Consumer(CarBigHouse bigHouse) {
            this.bigHouse = bigHouse;
        }

}

    /**
     * 這邊姑且當做是車子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();
        }
    }

}

上一篇：java關鍵字final使用方法詳解

下一篇：java nio基礎使用示例