服务器之家：专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|VB|R语言|JavaScript|易语言|vb.net|

服务器之家 - 编程语言 - Java教程 - java多线程和并发包入门示例

java多线程和并发包入门示例

2019-10-21 12:34java教程网 Java教程

这篇文章主要写了java多线程的使用方法和java并发包简单入门的示例，大家可以参考使用

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

}

 

  • 多线程
  • Java
  • 并发包

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    501 　 406 　 415 　 1433 　 2000 　 401 　 330 　 GOF23 　 堆栈类 　 微信公众号 　 注册服务 　 嵌套循环 　 critical 　 consul 　 spring 　 集合 　 volatile 　 Hibernate 　 Java 　 new 　 double 　 泛型 　 Java编程 　 遍历 　 设计模式 　 supplyAsync 　 制表符 　 回车 　 写入文件 　 JAVA8 　
    © 2019-2024 服务器之家(www.zzvips.com) 版权所有关于我们联系我们版权申明网站地图