一、 线程同步
关键字:synchronized
同步问题:当多个线程操作同一个对象时,就会出现线程对象对自己操作的数据不同步的问题。如下图:
synchronized方法:
1、synchronized代码块中的语句只能有一个线程在执行
2、任意一个对象都有一个标志位,有1和0两种状态
3、当程序执行到synchronized代码块的时候线程会检查对象的标志位是1还是0
4、如果是1则执行程序,同是将对象的标志位设置为0,其他线程执行到synchronized代码块时一看对象标志位为0 则线程会阻塞,一直等到对象的标志位为1再执行下面的程序
注意:在用synchronized标志对象时,对象必须是同一个对象才能保证线程同步
如:生产者与消费者模拟,生产者和消费者共同操作同一集合,当集合为空时,生产者生产一件商品放进集合,同时,消费者检测集合不为空,则买走一件东西,集合又为空,如此循环。
//商品类
public class Iphone {
public String name;
public Iphone(String name) {
this.name = name;
}
public static void main(String[] args) {
// 创建两个线程对象
ArrayList<Iphone> list = new ArrayList<Iphone>(); //构建队列,如此,保证消费者与生产者操作同一个队列
Consumer con = new Consumer(list);
Producer pro = new Producer(list);
pro.start();
con.start();
}
}
/**
* 生产者类
*/
public class Producer extends Thread {
ArrayList<Iphone> list; //此为消费者与生产者共同操作的队列
int value; //商品型号
public Producer(ArrayList<Iphone> list) {
this.list = list;
}
public void run() {
synchronized (list) { //保证线程同步
while (true) {
if (list.size() > 0) {
try {
list.wait(); //当队列不为零时,生产者不生产商品
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//队列为零,生产者生产商品
Iphone ih = new Iphone("iphone6S\t" + value);
list.add(ih); //生产的商品添加到队列
value++; //商品型号改变
System.out.println("生产了一个手机,型号为:" + ih.name);
list.notify(); // 释放,告诉消费者队列有商品,与阻塞方法并存
}
}
}
}
/**
* 消费者类
*
*/
public class Consumer extends Thread {
ArrayList<Iphone> list; //共同的队列
public Consumer(ArrayList<Iphone> list) {
this.list = list;
}
public void run() {
synchronized (list) { //线程同步锁
while (true) {
if (list.size() == 0) { //检测队列中是否有商品
try {
list.wait(); // 没有商品,则不执行下面的代码,阻塞
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//如果有商品,则买走
Iphone ih = list.remove(0); // 移除队列中第一个数据
System.out.println("买走了一个手机,型号为" + ih.name);
list.notify(); // 告诉生产者,释放
}
}
}
}
运行结果:保证了生产者与消费者平衡,线程同步
其中,运用到了wait和notify两个机制;
它们的作用是:一个是等待,一个是通知,当在一个对象上调用wait()方法时,当前线程就会进行等待状态,直到收到另一个对象的notify()发出通知,才会执行下一步计算
注意:1、必须在synchronized关键字也就是同步锁中运用;
2、同步锁锁定对象和wait、notify对象必须同一个;
3、当对象wait挂起状态时候是会释放同步锁的,也就是同步锁的对象标志位变为1。
二、线程池
1、线程生命周期
线程弊端:当线程run方法执行完毕后,线程也就死亡,同时同一个线程不能start两次。
如果一个线程需要多次执行,就需要线程池。
自定义线程池:
public class ThreadPool {
public ThreadPool(){
//预置好10个执行线程
for(int i=0;i<10;i++){ //
PoolWorker worker = new PoolWorker(taskList);
worker.start();//启动线程
}
System.out.println("******************线程池预置完毕**************************");
}
public static void main(String[] args) {
//创建.线程池对象
ThreadPool pool = new ThreadPool();
//决定线程执行次数
for(int i=0;i<60;i++){
MyTask task = new MyTask(); //线程执行方法类
pool.excute(task); //线程执行
}
}
}
public class MyTask { //线程执行的方法类
........
}
}
2、JDK内置的线程池:
java.util. concurrent包
JDK1.5起,引入的包,这个包下是关与并发编程使用的类库
java.util.concurrent.ExecutorService
//使用JDK内置的线程池,创建具有5个内置线程的池
ExecutorService exec = Executors.newFixedThreadPool(5);
//创建50个任务
for(int index = 0; index < 50; index++) {
SamplTask st=new SamplTask();
//开始执行
exec.execute(st);
}
//执行完任务后再关闭线程池,
exec.shutdown();