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