多线程开发
参考资料:
1.多线程概述
要实现多线程可以通过继承Thread和实现Runnable接口。不过这两者之间存在一些区别。其中最重要的区别就是,如果一个类继承Thread类,则不适合于多个线程共享资源,而实现了Runnable接口,就可以方便地实现资源的共享。
范例1:继承Thread类不能资源共享
package test; public class MyThreadDemo1 { public static void main(String args[]) { MyThread1 mt1 = new MyThread1(); MyThread1 mt2 = new MyThread1(); MyThread1 mt3 = new MyThread1(); mt1.start(); mt2.start(); mt3.start(); } static class MyThread1 extends Thread { private int ticket = 5; @Override public void run() { // TODO Auto-generated method stub for (int i = 0; i < 100; i++) if (ticket > 0)// 当余票大于0则买票 { System.out.println("卖一张票:剩余ticket=" + --ticket); // 这里--ticket表示卖了一张票后的余票 } } } }
程序运行结果:
卖票:剩余ticket=5 卖票:剩余ticket=4 卖票:剩余ticket=3 卖票:剩余ticket=2 卖票:剩余ticket=1 卖票:剩余ticket=5 卖票:剩余ticket=4 卖票:剩余ticket=3 卖票:剩余ticket=5 卖票:剩余ticket=4 卖票:剩余ticket=3 卖票:剩余ticket=2 卖票:剩余ticket=1 卖票:剩余ticket=2 卖票:剩余ticket=1
以上程序通过继承Thread类实现多线程,程序中启动了三个线程,但是三个线程分别买了各自的5张票,并没有达到资源(Ticket)共享的目的。
范例2:实现Runable接口可以资源共享
package test; public class MyRunableThreadDemo1 { public static void main(String args[]) { MyRunableThread1 mrt = new MyRunableThread1(); Thread t1 = new Thread(mrt); Thread t2 = new Thread(mrt); Thread t3 = new Thread(mrt); t1.start(); t2.start(); t3.start(); } static class MyRunableThread1 implements Runnable { private int ticket = 5; @Override public void run() { // TODO Auto-generated method stub for (int i = 0; i < 100; i++) if (ticket > 0)// 当余票大于0则买票 { System.out.println("卖一张票:剩余ticket=" + --ticket); // 这里--ticket表示卖了一张票后的余票 } } } }
程序运行结果:
从程序的运行结果中可以清楚地发现,虽然启动了3个线程, 但是三个线程一共才卖出去5张票,即ticket属性是被所有线程所共享的。
可见,实现Runnable接口相对于继承Thrad类来说,有如下显著优势:
- 适合多个相同程序代码的线程去处理同一资源的情况。
- 可以避免由于java单继承特性带来的局限
- 增强了程序的健壮性,代码能够被多个线程共享,代码与数据时独立的。
——————————————————————————————————————
范例2-2:增加输出线程名称的功能(ps:2012-6-9)
假如我们需要知道到底是哪一个线程在卖票,那么我们就必须输出线程的名称,对上述实例进行稍作修改该即可完成
首先是在实例化线程的时候可以传入线程名称,代码如下:
package test; public class MyRunableThreadDemo2 { public static void main(String args[]) { MyRunableThread1 mrt = new MyRunableThread1(); Thread t1 = new Thread(mrt, "t1"); Thread t2 = new Thread(mrt, "t2"); Thread t3 = new Thread(mrt, "t3"); t1.start(); t2.start(); t3.start(); } static class MyRunableThread1 implements Runnable { private int ticket = 5; @Override public void run() { // TODO Auto-generated method stub for (int i = 0; i < 100; i++) if (ticket > 0) { System.out.println(Thread.currentThread().getName() + "卖了一张票票,剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票 } } } }
上述程序运行结果如下:
t1在卖票:剩余ticket=4
t3在卖票:剩余ticket=2
t2在卖票:剩余ticket=3
t2在卖票:剩余ticket=1
t3在卖票:剩余ticket=0
但是多次你运行发现结果各不相同。
————————————————————————————————————————————
2.多线程的同步
多次运行范例2我们发现得到的结果可能都不相同。下面列举两个可能的输出结果
范例2可能的输出结果1
卖票:剩余ticket=4 卖票:剩余ticket=5 卖票:剩余ticket=2 卖票:剩余ticket=3 卖票:剩余ticket=1
范例2可能的输出结果2
卖票:剩余ticket=4 卖票:剩余ticket=2 卖票:剩余ticket=1 卖票:剩余ticket=5 卖票:剩余ticket=1
为了更形象地说明线程同步,我们在范例2中加入进程延时机制Thread.sleep(300);。代码如下所示:
package test; public class MyRunableThreadDemo2 { public static void main(String args[]) { MyRunableThread1 mrt = new MyRunableThread1(); Thread t1 = new Thread(mrt, "t1"); Thread t2 = new Thread(mrt, "t2"); Thread t3 = new Thread(mrt, "t3"); t1.start(); t2.start(); t3.start(); } static class MyRunableThread1 implements Runnable { private int ticket = 5; @Override public void run() { // TODO Auto-generated method stub for (int i = 0; i < 100; i++) if (ticket > 0) { try { Thread.sleep(300); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖了一张票票,剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票 } } } }
再次运行多线程主程序,得到的结果如下:
出现票数为负的情况是因为:
线程1在执行 ticket--之前,线程2 进入了 if (ticket > 0) 这个判断,这样当线程1 ticket--之后ticket==0了,线程2再次执行ticket--那么ticket==-1。相当于多执行了一次 ticket--
3.两种线程同步方法
为了解决范例2中出现的问题,我们通过引入同步机制来解决问题。同步又分为同步代码块和同步方法两种类型。
范例3:同步代码块
package test; public class MyRunableThreadDemo3 { public static void main(String args[]) { MyRunableThread1 mrt = new MyRunableThread1(); Thread t1 = new Thread(mrt, "t1"); Thread t2 = new Thread(mrt, "t2"); Thread t3 = new Thread(mrt, "t3"); t1.start(); t2.start(); t3.start(); } static class MyRunableThread1 implements Runnable { private int ticket = 200; @Override public void run() { //错误 // synchronized (this) { // while (ticket > 0) { // //// try { //// Thread.sleep(3); //// } catch (InterruptedException e) { //// e.printStackTrace(); //// } // System.out.println(Thread.currentThread().getName() // + "卖了一张票票,剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票 // } // } /** * 同步代码块 之前说到ticket出现负数的原因是线程1在执行 ticket--之前,线程2 进入了 if (ticket > 0) 这个判断, * 这样当线程1执行 ticket--之后ticket==0了,线程2再去执行ticket--,那么ticket==-1。相当于多执行了一次ticket--, * 因此我们将synchronized(this)放在了if(ticket>0)之前。for(int i=0;i<100;i++)用来表示连续执行100次。这里synchronized在 * for循环后面,因此每个线程都执行100次,彼此都有可能锁冲突。 * */ for(int i=0;i<100;i++) synchronized(this) { if(ticket>0) { try{ Thread.sleep(30); }catch(InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖了一张票票,剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票 } } } } }
之前说到ticket出现负数的原因是“线程1在执行 --ticket之前,线程2 进入了 if (ticket > 0) 这个判断, 这样当线程1执行 ticket--之后ticket==0了,线程2再去执行ticket--,那么ticket==-1,相当于多执行了一次ticket--”,
因此我们将synchronized(this)放在了if(ticket>0)之前。我们还可以发现外部有一个执行一般次的for循环for(int i=0;i<100;i++),这用来表示run方法中的这synchronized代码块会被执行100次。需要注意的是只有执行完synchronized代码块才会释放锁。因此每一个线程都有100次可能出现锁冲突,一个线程需要等待另外一个线程执行完synchronized代码块中的内容以后才可以访问这个代码块。
范例4:同步方法
package test; public class MyRunableThreadDemo4 { public static void main(String args[]) { MyRunableThread1 mrt = new MyRunableThread1(); Thread t1 = new Thread(mrt, "t1"); Thread t2 = new Thread(mrt, "t2"); Thread t3 = new Thread(mrt, "t3"); t1.start(); t2.start(); t3.start(); } static class MyRunableThread1 implements Runnable { private int ticket = 200; @Override public void run() { for (int i = 0; i < 100; i++) { sale(); } } public synchronized void sale() { if (ticket > 0) { try { Thread.sleep(30); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(Thread.currentThread().getName() + "卖了一张票票,剩余ticket=" + --ticket);// 这里--ticket表示卖了一张票后的余票 } } } }
这里将操作ticket资源的内容单独抽取出来作为一个方法来调用,然后同步该方法,保证同一时间只有一个进程调用该方法。
4生产者消费者案例
范例5:
package test; public class ThreadDeadLock { public static void main(String args[]) { Info info = new Info(); // info作为参数传入两个线程当中 ProducerThread pt = new ProducerThread(info); ConsumerThread ct = new ConsumerThread(info); Thread producer = new Thread(pt, "producer"); Thread consumer = new Thread(ct, "consumer"); producer.start(); consumer.start(); } //资源类 static class Info { private String name = "name"; private String content = "content"; public String getName() { return name; } public void setName(String name) { this.name = name; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } } // 生产者线程 static class ProducerThread implements Runnable { private Info info = null; // 构造函数,其参数是资源 public ProducerThread(Info info) { this.info = info; } @Override public void run() { // boolean flag=false; for (int i = 0; i < 10; i++) { this.info.setName("name" + i); try { Thread.sleep(90); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } this.info.setContent("content" + i); } } } static class ConsumerThread implements Runnable { private Info info = null; // 构造函数,其参数是资源 public ConsumerThread(Info info) { this.info = info; } @Override public void run() { for (int i = 0; i < 10; i++) { try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(this.info.getName() + ":-->" + this.info.getContent()); } } } }
程序输出:
范例5存在两个问题:
- 问题1:假设ProducerThread线程刚设置了name信息,还没有设置content信息,此时程序就切换到了ConsumerThread线程,那么ConsumerThread线程获取的是当前name与之前的content,所以输出结果会出现(比如:name1:-->content0)。这是因为name与content没有一起设置的原因,或者是说name与content信息不同步。
- 问题2:生产者放了若干次数据,消费者才开始取数据,或者是,消费者取完一个数据后,还没有等到生产者放入新的数据,又重复取出已去过的数据。(比如出现name1:-->content0 name1:-->content0,这个可以通过调节sleep来控制)
问题1 解决:加入同步
如果要为操作加入同步,可以通过定义同步方法的方式完成,即将设置名称和内容定义在一个方法里面,代码如范例6所示。
范例6
package test; public class ThreadDeadLock2 { public static void main(String args[]) { Info info = new Info(); // info作为参数传入两个线程当中 ProducerThread pt = new ProducerThread(info); ConsumerThread ct = new ConsumerThread(info); Thread producer = new Thread(pt, "producer"); Thread consumer = new Thread(ct, "consumer"); producer.start(); consumer.start(); } // 资源类 static class Info { private String name; private String content; //getter and setter public String getName() { return name; } public void setName(String name) { this.name = name; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } // 获取name与content信息 public synchronized void get() { try { Thread.sleep(300); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(this.getName() + ":-->" + this.getContent()); } // 设置name与content信息 public synchronized void set(String name, String content) { this.setName(name); try { Thread.sleep(300); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } this.setContent(content); } } // 生产者线程 static class ProducerThread implements Runnable { private Info info = null; // 构造函数,其参数是资源 public ProducerThread(Info info) { this.info = info; } @Override public void run() { for (int i = 0; i < 10; i++) { this.info.set("name" + i, "content" + i); } } } static class ConsumerThread implements Runnable { private Info info = null; // 构造函数,其参数是资源 public ConsumerThread(Info info) { this.info = info; } @Override public void run() { for (int i = 0; i < 10; i++) { try { Thread.sleep(100); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } this.info.get(); } } } }
程序运行结果
从程序的运行结果中可以发现,问题1:信息错乱的问题已经解决,但是依然存在问题2:重复读取的问题,以及漏读信息的问题(比如上述输出中name9:-->content9重复读取,而name5:-->content5被漏读了)。既然有重复读取,则肯定会有重复设置的问题,那么对于这样的问题,该如何解决呢?此时,就需要使用Object类。
Object类是所有类的父类,在此类中有以下几种方法是对线程操作有所支持的,如下表所示:
如果想让生产者不重复生产,消费者不重复消费,可以设置有一个标志位,假设标志位为boolean型变量,如果标志位内容为true,则表示可以生产,但是不能取走,如果标志位内容为false,则表示可以取走,不能生产。操作流程如下:
问题解决2——加入等待与唤醒
package edu.sjtu.erplab.thread; class Info{ private String name="name"; private String content="content"; private boolean flag=true; public synchronized void set(String name,String content) { if(!flag)//标志位为false,不可以生产 { try { super.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } this.setName(name); try { Thread.sleep(30); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } this.setContent(content); flag=false;//修改标志位为false,表示生产者已经完成资源,消费者可以消费。 super.notify();//唤醒消费者进程 } public synchronized void get() { if(flag) { try { super.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } try { Thread.sleep(30); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } System.out.println(this.getName()+":-->"+this.getContent()); flag=true;//修改标志位为true,表示消费者拿走资源,生产者可以生产。 super.notify();//唤醒生产者进程。 } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } } class Producer implements Runnable{ private Info info=null; public Producer(Info info) { this.info=info; } @Override public void run() { boolean flag=false; for(int i=0;i<10;i++) if(flag) { this.info.set("name+"+i, "content+"+i); flag=false; } else { this.info.set("name-"+i, "content-"+i); flag=true; } } } class Consumer implements Runnable{ private Info info=null; public Consumer(Info info) { this.info=info; } @Override public void run() { for(int i=0;i<10;i++) { try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } this.info.get(); } } } public class ThreadDeadLock { public static void main(String args[]) { Info info=new Info(); Producer pro=new Producer(info); Consumer con=new Consumer(info); new Thread(pro).start(); new Thread(con).start(); } }
程序运行结果:
name-0:-->content-0 name+1:-->content+1 name-2:-->content-2 name+3:-->content+3 name-4:-->content-4 name+5:-->content+5 name-6:-->content-6 name+7:-->content+7 name-8:-->content-8 name+9:-->content+9
ps:添加注释,解释Object.wait()与this.wait()(2012-5-12)
package edu.sjtu.erplab.thread; class Info{ private String name="name"; private String content="content"; private boolean flag=true;//标识位,表示生产者是否可以进行生产,true表示可以,false表示不可以。 //生产者线程调用的方法 public synchronized void set(String name,String content) { if(!flag)//如果不可以进行生产,则对Info对象加锁 { try { super.wait();//让拥有Info对象的生产者线程进入等待状态 //this.wait(); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } //如果可以进行生产,则设置name与content属性 this.setName(name); // try { // Thread.sleep(30); // } catch (InterruptedException e) { // // TODO Auto-generated catch block // e.printStackTrace(); // } this.setContent(content); System.out.println("生产:"+this.getName()+":-->"+this.getContent()); flag=false;//修改标志位为false,表示可以消费,不能生产。 super.notify();//唤醒拥有Info对象的线程 } //消费者线程调用的方法 public synchronized void get() { if(flag)//如果flag==true表示可以生产不可以消费, { try { super.wait();//让拥有Info资源的消费者线程进入等待 } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } } // try { // Thread.sleep(30); // } catch (InterruptedException e) { // // TODO Auto-generated catch block // e.printStackTrace(); // } System.out.println("消费:"+this.getName()+":-->"+this.getContent()); flag=true;//修改标志位为true,表示消费者拿走资源,生产者可以生产。 super.notify();//唤醒生产者进程。 } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } } //生产者线程 class Producer implements Runnable{ //生产者线程拥有的资源 private Info info=null; //构造函数 public Producer(Info info) { this.info=info; } @Override public void run() { boolean flag=false; for(int i=0;i<10;i++) if(flag) { this.info.set("name+"+i, "content+"+i); flag=false; } else { this.info.set("name-"+i, "content-"+i); flag=true; } } } //消费者线程 class Consumer implements Runnable{ //消费者线程拥有的资源 private Info info=null; //构造函数 public Consumer(Info info) { this.info=info; } @Override public void run() { for(int i=0;i<10;i++) { try { Thread.sleep(10); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } this.info.get(); } } } public class ThreadDeadLock { public static void main(String args[]) { Info info=new Info(); Producer pro=new Producer(info); Consumer con=new Consumer(info); new Thread(pro).start(); new Thread(con).start(); } }
运行结果
生产:name-0:-->content-0 消费:name-0:-->content-0 生产:name+1:-->content+1 消费:name+1:-->content+1 生产:name-2:-->content-2 消费:name-2:-->content-2 生产:name+3:-->content+3 消费:name+3:-->content+3 生产:name-4:-->content-4 消费:name-4:-->content-4 生产:name+5:-->content+5 消费:name+5:-->content+5 生产:name-6:-->content-6 消费:name-6:-->content-6 生产:name+7:-->content+7 消费:name+7:-->content+7 生产:name-8:-->content-8 消费:name-8:-->content-8 生产:name+9:-->content+9 消费:name+9:-->content+9
相关推荐
同步控制是并发程序必不可少的重要手段,本文我们将通过重入锁、读写锁、信号量、倒计数器和循环栅栏以及他们的实例来介绍Java并发程序中的同步控制。 目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ...
资源名称:Java多线程与并发库高级应用视频教程22集资源目录:【】01传统线程技术回顾【】02传统定时器技术回顾【】03传统线程互斥技术【】04传统线程同步通信技术【】04传统线程同步通信技术_分割纪录【】05线程...
Java线程:线程的同步-同步方法 Java线程:线程的同步-同步块 Java线程:并发协作-生产者消费者模型 Java线程:并发协作-死锁 Java线程:volatile关键字 Java线程:新特征-线程池 Java线程:新特征-有返回值的...
详细的讲述了多线程的各种用法 Java线程:概念与原理 Java线程:创建与启动 Java线程:线程栈模型与线程的变量 Java线程:线程状态的转换 Java线程:线程的同步与锁 Java线程:线程的交互 Java线程:线程的调度-休眠...
Java线程:线程的同步 33 一、 同步方法 35 二、 同步块 36 三、 volatile关键字 38 四、 使用synchronized关键字要注意以下四点 39 五、 关于同步和锁定的一些问题 41 Java线程:并发协作-线程的交互 47 Java线程:...
Java分布式应用学习笔记05多线程下的并发同步器
java.util.concurrent 包含许多线程安全、测试良好、高性能的并发构建块。不客气地说,创建 java.util.concurrent 的目的就是要实现 Collection 框架对数据结构所执行的并发操作。通过提供一组可靠的、高性能并发...
1)CountDownLatch(同步倒数计数器:等待多线程(或者多步骤)完成) 2)CyclicBarrier(循环屏障:同步屏障) 3)Semaphore(信号量:控制并发进程数) 主要参考资料:java并发编程的艺术、Java并发——...
针对高可靠性、高质量的Java并行多任务程序设汁,分析了Java多线程机制的原理及其实现技术.研究了程序并发过程中的同步机制和交互通信机制,比较了基于操作系统级和基于Java多线程级并发机制的实现结构,总结了并发...
用java实现多线程并发中的读者与写者问题,能够实现多线程对临界资源的同步有序访问。 具体实现为: 给定一个队列A[1-10][1-100000]、元素编号1-10,其中每个元素包含10万个随机数。创建若干个线程,各循环100次;...
模拟实现多线程处理银行的实时转账交易,代码完整,可以完美运行~
Java并发编程的核心概念包括: 线程(Thread):线程是程序执行流的最小单元。...原子操作(Atomic Operations):原子操作是不可中断的操作,即在多线程环境中,这些操作要么完全执行,要么完全不执行。
包括java的Thread类,同步块(synchronized),可重入锁,Object方法以及对象监视器等内容。
java多线程每个线程挨着打印ABC的4种实现方式,有4个线程t1、t2、t3、t4,t1打印A后t2打印A再t3打印A再t4打印A,然后从新回到t1打印B再t2打印B...t4打印B... 4个线程轮流打印abc... 一个线程可以理解为一个人,打印...
1.讲解了Java多线程的基础, 包括Thread类的核心API的使用。2.讲解了在多线程中对并发访问的控制, 主要就是synchronized的使用, 由于此关键字在使用上非常灵活, 所以书中用了很多案例来介绍此关键字的使用, 为...
本篇文章提供了20道高难度的Java多线程编程面试题及详细解析,旨在帮助开发者展示出卓越的并发编程能力。在当今高并发的应用场景下,对多线程编程的理解和应用是评估面试者的重要指标。通过这些高难度问题,您将全面...
本教程主要讲解了java多线程的基本概念,多线程与单线程的区别,线程同步,线程死锁等内容
1.1为什么需要多线程 1.2不安全示例 1.3并发问题的根源 1.4JMM 1.5线程安全的分类 1.6线程安全的方法 二、线程基础 2.1状态 2.2使用方式 2.3基础机制 2.4中断 2.5互斥同步 2.6线程合作 三、...