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

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
    }

}

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

}

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多线程和并发包入门示例

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

java多线程入门知识及示例程序

Java使用Thread创建多线程并启动操作示例

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

Java使用Thread创建多线程并启动操作示例

java多线程编程同步器Future和FutureTask解析及代码示例

Java中多线程阻塞和唤醒的示例代码

Java多线程之Callable和Future的详细介绍（代码示例）

Java中多线程阻塞和唤醒的示例代码

Java多线程之Callable和Future的详细介绍（代码示例）