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

}

(0)

相关推荐

  • Java Web项目中使用Socket通信多线程、长连接的方法

    很多时候在javaweb项目中我们需要用到Socket通信来实现功能,在web中使用Socket我们需要建立一个监听程序,在程序启动时,启动socket监听.我们的应用场景是在java项目中,需要外接如一个硬件设备,通过tcp通信,获取设备传上来的数据,并对数据做回应. 先看一下web的监听代码: import javax.servlet.ServletContextEvent; import javax.servlet.ServletContextListener; public class

  • Java多线程中线程间的通信实例详解

    Java多线程中线程间的通信 一.使用while方式来实现线程之间的通信 package com.ietree.multithread.sync; import java.util.ArrayList; import java.util.List; public class MyList { private volatile static List list = new ArrayList(); public void add() { list.add("apple"); } publ

  • Java多线程下载的实现方法

    复制代码 代码如下: package cn.me.test; import java.io.InputStream; import java.io.RandomAccessFile; import java.net.HttpURLConnection; import java.net.URL; /** * 多线程下载 * 1:使用RandomAccessFile在任意的位置写入数据. * 2:需要计算第一个线程下载的数据量,可以平均分配.如果不够平均时, *    则直接最后一个线程处理相对较少

  • 深入理解JAVA多线程之线程间的通信方式

    一,介绍 本总结我对于JAVA多线程中线程之间的通信方式的理解,主要以代码结合文字的方式来讨论线程间的通信,故摘抄了书中的一些示例代码. 二,线程间的通信方式 ①同步 这里讲的同步是指多个线程通过synchronized关键字这种方式来实现线程间的通信. 参考示例: public class MyObject { synchronized public void methodA() { //do something.... } synchronized public void methodB()

  • java多线程实现服务器端与多客户端之间的通信

    用java语言构建一个网络服务器,实现客户端和服务器之间通信,实现客户端拥有独立线程,互不干扰. 应用多线程来实现服务器与多线程之间的通信的基本步骤 服务器端创建ServerSocket,循环调用accept()等待客户端链接 客户端创建一个Socket并请求和服务器端链接 服务器端接受客户端请求,创建socekt与该客户端建立专线链接 建立链接的socket在一个单独的线程上对话 服务器继续等待新的链接 服务器端Server.java package test.concurrent.socke

  • Java多线程的用法详解

    1.创建线程 在Java中创建线程有两种方法:使用Thread类和使用Runnable接口.在使用Runnable接口时需要建立一个Thread实例.因此,无论是通过Thread类还是Runnable接口建立线程,都必须建立Thread类或它的子类的实例.Thread构造函数: public Thread( );  public Thread(Runnable target);  public Thread(String name);  public Thread(Runnable target

  • java 多线程-线程通信实例讲解

    线程通信的目标是使线程间能够互相发送信号.另一方面,线程通信使线程能够等待其他线程的信号. 通过共享对象通信 忙等待 wait(),notify()和 notifyAll() 丢失的信号 假唤醒 多线程等待相同信号 不要对常量字符串或全局对象调用 wait() 通过共享对象通信 线程间发送信号的一个简单方式是在共享对象的变量里设置信号值.线程 A 在一个同步块里设置 boolean 型成员变量 hasDataToProcess 为 true,线程 B 也在同步块里读取 hasDataToProc

  • Java多线程实现异步调用的方法

    在JAVA平台,实现异步调用的角色有如下三个角色:调用者 提货单   真实数据 一个调用者在调用耗时操作,不能立即返回数据时,先返回一个提货单.然后在过一断时间后凭提货单来获取真正的数据. 去蛋糕店买蛋糕,不需要等蛋糕做出来(假设现做要很长时间),只需要领个提货单就可以了(去干别的事情),等到蛋糕做好了,再拿提货单取蛋糕就可以了. public class Main { public static void main(String[] args) { System.out.println("ma

  • Java Socket实现多线程通信功能示例

    本文实例讲述了Java Socket实现多线程通信功能的方法.分享给大家供大家参考,具体如下: 前面的文章<Java Socket实现单线程通信的方法示例>说到怎样写一个最简单的Java Socket通信,但是文章中的例子有一个问题就是Server只能接受一个Client请求,当第一个Client连接后就占据了这个位置,后续Client不能再继续连接,所以需要做些改动,当Server没接受到一个Client连接请求之后,都把处理流程放到一个独立的线程里去运行,然后等待下一个Client连接请求

  • Java Socket实现单线程通信的方法示例

    本文实例讲述了Java Socket实现单线程通信的方法.分享给大家供大家参考,具体如下: 现在做Java直接使用Socket的情况是越来越少,因为有很多的选择可选,比如说可以用spring,其中就可以支持很多种远程连接的操作,另外jboss的remoting也是不错的选择,还有Apache的Mina等等,但是在有些时候一些特殊情况仍然逃脱不了直接写Socket的情况,比如公司内部一些莫名其妙的游戏规则. 废话不说了,下面就看看如果自己写Socket应该怎么做吧. 首先是写一个Server类,这

  • java基本教程之线程休眠 java多线程教程

    本章涉及到的内容包括:1. sleep()介绍2. sleep()示例3. sleep() 与 wait()的比较 1. sleep()介绍sleep() 定义在Thread.java中.sleep() 的作用是让当前线程休眠,即当前线程会从"运行状态"进入到"休眠(阻塞)状态".sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间:在线程重新被唤醒时,它会由"阻塞状态"变成"就绪状态",从而等待cpu的调度执行

随机推荐