当前位置:  编程技术>java/j2ee

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

    来源: 互联网  发布时间：2014-10-29

    本文导语:  一、java多线程基本入门java多线程编程还是比较重要的，在实际业务开发中经常要遇到这个问题。 java多线程，传统创建线程的方式有两种。 1、继承自Thread类，覆写run方法。 2、实现Runnable接口，实现run方法。 启动线程的方法...

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

    }

    /**
     * 


     * 
     * 主线程为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
     * @param t
     * @throws InstantiationException
     * @throws IllegalAccessException
     * @throws InterruptedException
     */
    public static 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();
            }
        }
    }

    /**
     * 


     * 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 carList = new ArrayList();// 这边模拟用来放汽车的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 carList = new ArrayList();// 这边模拟用来放汽车的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 carList = new ArrayList();// 这边模拟用来放汽车的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开发包 qq-t-java-sdk
  • Git的Java开发包 JGit
  • Java国际化开发包 Nuiton-i18n
  • Java并发开发包 util.concurrent
  • Java串口开发包 RXTX
  • WebDAV 的 Java 客户端开发包 Sardine
  • Java2D游戏开发包 loon-simple
  • Java二维条形码开发包 QR Code Library
  • Java的XML开发包 JAXB
  • protobuf​的Java开发包 jprotobuf
  • Java的OpenGL开发包 JOGL
  • Java的RDF开发包 Sesame
  • Java的XML开发包 jOOX
  • Java多线程开发包 JEgg
  • 我想学JAVA ,是买THINK IN JAVA 还是JAVA2核心技术:卷1 好??? iis7站长之家
  • Java的DNS开发包 dnsjava
  • 网上哪儿有java的企业级开发包1。3版本的，我需要在win 98上跑，谢谢！
  • Java HTTP 客户端开发包 jcabi-http
  • SOS！！！救救小女子一命！！…… 有谁知道java语言中的PDF开发包？
  • Java 的 zip 开发包 ZIP4J
  • andriod下java socket网络编程:java socket客户端服务端代码示例
  • 输出java进程的jstack信息示例分享 通过线程堆栈信息分析java线程
  • java Servlet实现Session创建存取以及url重写代码示例
  • java 四舍五入使java保留2位小数示例讲解
  • java进行error捕获和处理示例(java异常捕获)
  • java去除集合中重复元素示例分享 java去除重复
  • java读取csv文件示例分享(java解析csv文件)
  • java求三个数的最大值的示例分享
  • java生成字母数字组合的随机数示例 java生成随机数
  • java实现网页解析示例
  • java协变返回类型使用示例
    •  
    本站(WWW.)旨在分享和传播互联网科技相关的资讯和技术，将尽最大努力为读者提供更好的信息聚合和浏览方式。
    本站(WWW.)站内文章除注明原创外，均为转载、整理或搜集自网络。欢迎任何形式的转载，转载请注明出处。












  • 相关文章推荐
  • Java中多线程相关类Thread介绍
  • java 线程，对当前线程（非主线程）调用sleep,为什么主线程（窗口）也没反应了
  • java基本教程之多线程基本概念 java多线程教程
  • 请问在java多线程中，是只有run(){}内的代码运行在一个新线程下呢？还是这个类中的代码都运行在一个新线程下？
  • 用什么方法可以查看在windows下jvm下运行当前java程序的线程数和线程名称?
  • java多线程编程之捕获子线程异常示例
  • java线程怎么调用java的application.class?
  • java多线程编程之使用runnable接口创建线程
  • java线程中如何降低CPU的占用率？我这几个线程会不会死锁？
  • java线程之使用Runnable接口创建线程的方法
  • java 多线程问题
  • Java线程的相关方法详细解析
  • 紧急求助java多线程编程！！！！！！！！！！！！！
  • java线程，回答得比较深就好了
  • Java多线程之中断线程(Interrupt)的使用详解
  • 关于java线程调度优先级
  • java基本教程之线程让步 java多线程教程
  • Java多线程单元测试 Thread Weaver
  • 求教JAVA中的延时函数！不是用于线程中的！
  • java中多线程的问题
  • Java多线程实时分析工具 mtrat
  • java命名空间java.sql类types的类成员方法: java_object定义及介绍
  • 我想学JAVA ,是买THINK IN JAVA 还是JAVA2核心技术:卷1 好???
  • java命名空间java.awt.datatransfer类dataflavor的类成员方法: imageflavor定义及介绍
  • 请问Java高手,Java的优势在那里？？,Java主要适合于开发哪类应用程序
  • java命名空间java.lang.management类managementfactory的类成员方法: getcompilationmxbean定义及介绍
  • 如何将java.util.Date转化为java.sql.Date?数据库中Date类型对应于java的哪个Date呢
  • java命名空间java.lang.management接口runtimemxbean的类成员方法: getlibrarypath定义及介绍
  • 谁有电子版的《Java编程思想第二版（Thinking in java second)》和《Java2编程详解（special edition java2)》？得到给分
  • java命名空间java.lang.management接口runtimemxbean的类成员方法: getstarttime定义及介绍
  • 本人想学java，请问java程序员的待遇如何，和java主要有几个比较强的方向


    • 站内导航:


    特别声明:169IT网站部分信息来自互联网,如果侵犯您的权利,请及时告知,本站将立即删除！

    ©2012-2021,,E-mail:www_#163.com(请将#改为@)

    浙ICP备11055608号-3