java线程初级总结【mldn吧】_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：79贴子：
java线程初级总结收藏
1.多线程概念
程序：计算机指令的**，是一段静态的代码，还有指令和数据的文件。
进程：进程是程序一次动态执行的所有过程，进程包括运行中的程序和程序所使用到的内存和系统资源。
线程：线程是程序中的一个执行流，每个线程都有自己的专有寄存器，但内存单元是共享的，即不同的线程可以执行同样的函数。
并发编程：指由若干个可同时执行的程序模块组成程序的程序设计方法。这种可同时执行的程序模块就是进程。2.为什么使用多线程
在java多线程模型中，多个线程共存于同一块内存中，且共享资源，线程之间的通信非常容易。
java程序可以并行处理，很大提高了程序的效率以及功能。3.java线程的模型
抢占式调度模型
线程调度程序挑选线程时，将选择处于就绪状态且优先级最高的线程。
如果多个线程具有相同的优先级，它们将被轮流调度。4.java线程优先级
优先级是从0到10的整数，并且它仅表示线程之间的相对关系；
当多个线程并行执行时，具有较高优先级的线程将获得较多的CPU时间片；
Thread类包含的常量有：
1. public static final int MAX_PRIORITY： 最大优先级，值是10。
2. public static final int MIN_PRIORITY：
最小优先级，值是1。
3. public static final int NORM_PRIORITY：缺省优先级，值是5。5.主线程
java中建立了一个类，当运行到该类的时候，java虚拟机自动创建一个一个线程调用main函数，这就是它的主线程。6.建立线程
当一个Thread类或其子类的对象被声明冰箱被创建时。此时它已经有了相应的内存空间和其他资源，但是并没有开始执行它内部的代码。
void run():用该方法来执行线程。
void start():开始执行run部分的代码。
static void sleep(long millis)throws InterruptedException:将可运行对象置为休眠状态，休眠时间为指定的毫秒。
20年老品牌,一级代理,专注肯尼亚海运空运,报关一站式服务
7.如何知道线程是否已经结束
可以调用isAlive()这个方法来判断：isAlive方法可以返回线程的状态，若true则线程处在可运行或不可运行状态； 若false则线程处在新创建或死亡状态。
还有join()方法，它会等待线程结束。相当于下面的语句：
while(thread.isAlive())
thread.sleep(10);
(InterruptedException
} 8.动画实现
创建多个Thread类或其子类的对象，循环开始start(),然后在run()函数中实现。
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或Java多线程初学者指南（4）：线程的生命周期
Java多线程初学者指南（4）：线程的生命周期
　　与人有生老病死一样，线程也同样要经历开始（等待）、运行、挂起和停止四种不同的状态。这四种状态都可以通过Thread类中的方法进行控制。下面给出了Thread类中和这四种状态相关的方法。
&&&&//&开始线程&&& public&void&start(&);&&& public&void&run(&);&&&&//&挂起和唤醒线程&&& public&void&resume(&);&&&&&//&不建议使用&&& public&void&suspend(&);&&&&//&不建议使用&&&&public&static&void&sleep(long&millis);&&& public&static&void&sleep(long&millis,&int&nanos);&&& //&终止线程&&& public&void&stop(&);&&&&&&&//&不建议使用&&&&public&void&interrupt(&);&&& //&得到线程状态&&&&public&boolean&isAlive(&);&&&&public&boolean&isInterrupted(&);&&& public&static&boolean&interrupted(&);&&& //&join方法&&&&public&void&join(&)&throws&InterruptedE
　　一、创建并运行线程
　　线程在建立后并不马上执行run方法中的代码，而是处于等待状态。线程处于等待状态时，可以通过Thread类的方法来设置线程不各种属性，如线程的优先级（setPriority）、线程名（setName）和线程的类型（setDaemon）等。
　　当调用start方法后，线程开始执行run方法中的代码。线程进入运行状态。可以通过Thread类的isAlive方法来判断线程是否处于运行状态。当线程处于运行状态时，isAlive返回true，当isAlive返回false时，可能线程处于等待状态，也可能处于停止状态。下面的代码演示了线程的创建、运行和停止三个状态之间的切换，并输出了相应的isAlive返回值。
package&chapter2;public&class&LifeCycle&extends&Thread{&&&&public&void&run()&&&&{&&&&&&&&int&n&=&0;&&&&&&&&while&((++n)&&&1000);&&&&&&&&&&&&}&&&&&&&&&public&static&void&main(String[]&args)&throws&Exception&&&&{&&&&&&&&LifeCycle&thread1&=&new&LifeCycle();&&&&&&&&System.out.println("isAlive:&"&+&thread1.isAlive());&&&&&&&&thread1.start();&&&&&&&&System.out.println("isAlive:&"&+&thread1.isAlive());&&&&&&&&thread1.join();&&//&等线程thread1结束后再继续执行&&&&&&&&&System.out.println("thread1已经结束!");&&&&&&&&System.out.println("isAlive:&"&+&thread1.isAlive());&&&&}}
　　要注意一下，在上面的代码中使用了join方法，这个方法的主要功能是保证线程的run方法完成后程序才继续运行，这个方法将在后面的文章中介绍
　　上面代码的运行结果：
isAlive:&falseisAlive:&truethread1已经结束!isAlive:&false
　　二、挂起和唤醒线程
　　一但线程开始执行run方法，就会一直到这个run方法执行完成这个线程才退出。但在线程执行的过程中，可以通过两个方法使线程暂时停止执行。这两个方法是suspend和sleep.在使用suspend挂起线程后，可以通过resume方法唤醒线程。而使用sleep使线程休眠后，只能在设定的时间后使线程处于就绪状态（在线程休眠结束后，线程不一定会马上执行，只是进入了就绪状态，等待着系统进行调度）。
　　虽然suspend和resume可以很方便地使线程挂起和唤醒，但由于使用这两个方法可能会造成一些不可预料的事情发生，因此，这两个方法被标识为deprecated（抗议）标记，这表明在以后的jdk版本中这两个方法可能被删除，所以尽量不要使用这两个方法来操作线程。下面的代码演示了sleep、suspend和resume三个方法的使用。
package&chapter2;public&class&MyThread&extends&Thread{&&&&class&SleepThread&extends&Thread&&&&{&&&&&&&&public&void&run()&&&&&&&&{&&&&&&&&&&&&try&&&&&&&&&&&&{&&&&&&&&&&&&&&&&sleep(2000);&&&&&&&&&&&&}&&&&&&&&&&&&catch&(Exception&e)&&&&&&&&&&&&{&&&&&&&&&&&&}&&&&&&&&}&&&&}&&&&public&void&run()&&&&{&&&&&&&&while&(true)&&&&&&&&&&&&System.out.println(new&java.util.Date().getTime());&&&&}&&&&public&static&void&main(String[]&args)&throws&Exception&&&&{&&&&&&&&MyThread&thread&=&new&MyThread();&&&&&&&&SleepThread&sleepThread&=&thread.new&SleepThread();&&&&&&&&sleepThread.start();&//&开始运行线程sleepThread&&&&&&&&sleepThread.join();&&//&使线程sleepThread延迟2秒&&&&&&&&thread.start();&&&&&&&&boolean&flag&=&&&&&&&&&while&(true)&&&&&&&&{&&&&&&&&&&&&sleep(5000);&&//&使主线程延迟5秒&&&&&&&&&&&&flag&=&!&&&&&&&&&&&&if&(flag)&&&&&&&&&&&&&&&&thread.suspend();&&&&&&&&&&&&&else&&&&&&&&&&&&&&&&thread.resume();&&&&&&&&}&&&&}}
　　从表面上看，使用sleep和suspend所产生的效果类似，但sleep方法并不等同于suspend.它们之间最大的一个区别是可以在一个线程中通过suspend方法来挂起另外一个线程，如上面代码中在主线程中挂起了thread线程。而sleep只对当前正在执行的线程起作用。在上面代码中分别使sleepThread和主线程休眠了2秒和5秒。在使用sleep时要注意，不能在一个线程中来休眠另一个线程。如main方法中使用thread.sleep（2000）方法是无法使thread线程休眠2秒的，而只能使主线程休眠2秒。
　　在使用sleep方法时有两点需要注意：
　　1. sleep方法有两个重载形式，其中一个重载形式不仅可以设毫秒，而且还可以设纳秒（1，000，000纳秒等于1毫秒）。但大多数操作系统平台上的Java虚拟机都无法精确到纳秒，因此，如果对sleep设置了纳秒，Java虚拟机将取最接近这个值的毫秒。
　　2. 在使用sleep方法时必须使用throws或try{……}catch{……}.因为run方法无法使用throws，所以只能使用try{……}catch{……}.当在线程休眠的过程中，使用interrupt方法（这个方法将在2.3.3中讨论）中断线程时sleep会抛出一个InterruptedException异常。sleep方法的定义如下：
public&static&void&sleep(long&millis)&&throws&InterruptedExceptionpublic&static&void&sleep(long&millis,&&int&nanos)&&throws&InterruptedException
　　三、终止线程的三种方法
　　有三种方法可以使终止线程。
　　1.& 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
　　2.& 使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。
　　3.& 使用interrupt方法中断线程。
　　1. 使用退出标志终止线程
　　当run方法执行完后，线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求，或是其他的需要循环处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while（true）{……}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。下面给出了一个利用退出标志终止线程的例子。
package&chapter2;public&class&ThreadFlag&extends&Thread{&&&&public&volatile&boolean&exit&=&&&&&public&void&run()&&&&{&&&&&&&&while&(!exit);&&&&}&&&&public&static&void&main(String[]&args)&throws&Exception&&&&{&&&&&&&&ThreadFlag&thread&=&new&ThreadFlag();&&&&&&&&thread.start();&&&&&&&&sleep(5000);&//&主线程延迟5秒&&&&&&&&thread.exit&=&&&//&终止线程thread&&&&&&&&thread.join();&&&&&&&&System.out.println("线程退出!");&&&&}}
　　在上面代码中定义了一个退出标志exit，当exit为true时，while循环退出，exit的默认值为false.在定义exit时，使用了一个Java关键字volatile，这个关键字的目的是使exit同步，也就是说在同一时刻只能由一个线程来修改exit的值，
　　2. 使用stop方法终止线程
　　使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程：
thread.stop();
　　虽然使用上面的代码可以终止线程，但使用stop方法是很危险的，就象突然关闭计算机电源，而不是按正常程序关机一样，可能会产生不可预料的结果，因此，并不推荐使用stop方法来终止线程。
　　3. 使用interrupt方法终止线程
　　使用interrupt方法来终端线程可分为两种情况：
　　（1）线程处于阻塞状态，如使用了sleep方法。
　　（2）使用while（！isInterrupted（））{……}来判断线程是否被中断。
　　在第一种情况下使用interrupt方法，sleep方法将抛出一个InterruptedException例外，而在第二种情况下线程将直接退出。下面的代码演示了在第一种情况下使用interrupt方法。
package&chapter2;public&class&ThreadInterrupt&extends&Thread{&&&&public&void&run()&&&&{&&&&&&&&try&&&&&&&&{&&&&&&&&&&&&sleep(50000);&&//&延迟50秒&&&&&&&&}&&&&&&&&catch&(InterruptedException&e)&&&&&&&&{&&&&&&&&&&&&System.out.println(e.getMessage());&&&&&&&&}&&&&}&&&&public&static&void&main(String[]&args)&throws&Exception&&&&{&&&&&&&&Thread&thread&=&new&ThreadInterrupt();&&&&&&&&thread.start();&&&&&&&&System.out.println("在50秒之内按任意键中断线程!");&&&&&&&&System.in.read();&&&&&&&&thread.interrupt();&&&&&&&&thread.join();&&&&&&&&System.out.println("线程已经退出!");&&&&}}
　　上面代码的运行结果如下：
&&&&在50秒之内按任意键中断线程!&&& sleep&interrupted&&& 线程已经退出!
　　在调用interrupt方法后， sleep方法抛出异常，然后输出错误信息：sleep interrupted.
　　注意：在Thread类中有两个方法可以判断线程是否通过interrupt方法被终止。一个是静态的方法interrupted（），一个是非静态的方法isInterrupted（），这两个方法的区别是interrupted用来判断当前线是否被中断，而isInterrupted可以用来判断其他线程是否被中断。因此，while （！isInterrupted（））也可以换成while （！Thread.interrupted（））。
H3C认证Java认证Oracle认证
基础英语软考英语项目管理英语职场英语
.NETPowerBuilderWeb开发游戏开发Perl
二级模拟试题一级模拟试题一级考试经验四级考试资料
软件测试软件外包系统分析与建模敏捷开发
法律法规历年试题软考英语网络管理员系统架构设计师信息系统监理师
高级通信工程师考试大纲设备环境综合能力
路由技术网络存储无线网络网络设备
CPMP考试prince2认证项目范围管理项目配置管理项目管理案例项目经理项目干系人管理
职称考试题目
招生信息考研政治
网络安全安全设置工具使用手机安全
生物识别传感器物联网传输层物联网前沿技术物联网案例分析
Java核心技术J2ME教程
Linux系统管理Linux编程Linux安全AIX教程
Windows系统管理Windows教程Windows网络管理Windows故障
数据库开发Sybase数据库Informix数据库
&&&&&&&&&&&&&&&
希赛网 版权所有 & &&博客访问： 127274
博文数量： 59
博客积分： 1410
博客等级： 上尉
技术积分： 261
注册时间：
IT168企业级官微
微信号：IT168qiye
系统架构师大会
微信号：SACC2013
分类： Java
原文地址： 作者：
&& & &一般来说：有两种方法可以知道线程的结束。一：可以在线程中调用isAlive()；二：调用join()方法&& & & 一 &线程中调用isAlive()方法，它的一般形式如下：final boolean isAlive()；如果调用他的线程仍在运行，返回true，否则，返回false；&& & & & & &用法：NewThread&th1&=&new&NewThread("Thread1");&& & & & & & & & &th1.t.isAlive()；&& & &&& & & 二 &线程中调用join()方法，它的一般形式如下：final void join() throws InterruptedException；这个方法一直在等待，直到调用他的线程终止。join还有另一种形式允许指定等待线程终止的最大时间。&& & & & & &用法：NewThread&th1&=&new&NewThread("Thread1");&& & & & & & & & &th1.t.join();例子如下：package thread;public class NewThread implements Runnable{&&&&Thread t;&&&&String name="";&&&&NewThread(String name){&&&&&&&&this.name=name;&&&&&&&&t = new Thread(this,name);&&&&&&&&//t = new Thread();&&&&&&&&System.out.println("Child Thread:"+t);&&&&&&&&//t.run();&&&&&&&&t.start();&&&&}&&&&public void run()&&&&{&&&&&&&&try {&&&&&&&&&&&&for (int n = 5; n & 0; n--) {&&&&&&&&&&&&&&&&System.out.println(name+":" + n);&&&&&&&&&&&&&&&&Thread.sleep(1000);&&&&&&&&&&&&}&&&&&&&&} catch (Exception e) {&&&&&&&&&&&&// TODO: handle exception&&&&&&&&&&&&System.out.println(name+":"+"interrupted");&&&&&&&&}&&&&&&&&System.out.println("Exiting "+name+" thread");&&&&}}package thread;public class DemoJoin {&&&&/**&&&& * @param args&&&& */&&&&public static void main(String[] args) {&&&&&&&&// TODO Auto-generated method stub&&&&&&&&NewThread th1 = new NewThread("Thread1");&&&&&&&&NewThread th2 = new NewThread("Thread2");&&&&&&&&NewThread th3 = new NewThread("Thread3");&&&&&&&&&&&&&&&&System.out.println("Thread1 is Alive:"+th1.t.isAlive());&&&&&&&&System.out.println("Thread2 is Alive:"+th2.t.isAlive());&&&&&&&&System.out.println("Thread3 is Alive:"+th3.t.isAlive());&&&&&&&&&&&&&&&&&&&&try {&&&&&&&&&&&&&&&&System.out.println("Waiting for Thread finished");&&&&&&&&&&&&&&&&th1.t.join();&&&&&&&&&&&&&&&&th2.t.join();&&&&&&&&&&&&&&&&th3.t.join();&&&&&&&&&&&&} catch (Exception e) {&&&&&&&&&&&&&&&&// TODO: handle exception&&&&&&&&&&&&&&&&System.out.println("Main thread Interrupt");&&&&&&&&&&&&}&&&&&&&&&&&&&&&&&&&&&&&&System.out.println("Thread1 is Alive:"+th1.t.isAlive());&&&&&&&&&&&&System.out.println("Thread2 is Alive:"+th2.t.isAlive());&&&&&&&&&&&&System.out.println("Thread3 is Alive:"+th3.t.isAlive());&&&&&&&&&&&&System.out.println("Main Thread existing");&&&&}}
阅读(423) | 评论(0) | 转发(0) |
相关热门文章
给主人留下些什么吧！~~
请登录后评论。拓胜浸入式IT培训，让天下没有难学的课程！
您现在正在浏览：
& Java多线程的用法最全详解
发布时间：
10:30:44 & 作者：拓胜科技 & 来源：拓胜科技 & 浏览次数： 次 &
摘要：Java多线程的用法最全详解，如果你对Java的多线程机制并没有深入的研究，那么本文可以帮助你更透彻地理解Java多线程的原理以及使用方法……
Java多线程的用法最全详解，学习java做一个java工程师不但待遇高，而且前途无可限量。为什么这样说呢？因为java程序语言作为最流行的计算机开发语言之一，几乎所有的系统、软件、app、网页等都是需要用到java的。
最全面的java多线程用法解析，如果你对Java的多线程机制并没有深入的研究，那么本文可以帮助你更透彻地理解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, String name);
public&Thread(ThreadGroup group, Runnable target);
public&Thread(ThreadGroup group, String name);
public&Thread(ThreadGroup group, Runnable target, String name);
public&Thread(ThreadGroup group, Runnable target, String name,&long&stackSize);
方法一：继承Thread类覆盖run方法
public class ThreadDemo1 {
public static void main(String[] args){
Demo d = new Demo();
d.start();
for(int i=0;i&60;i++){
System.out.println(Thread.currentThread().getName()+i);
class Demo extends Thread{
public void run(){
for(int i=0;i&60;i++){
System.out.println(Thread.currentThread().getName()+i);
public class ThreadDemo2 {
public static void main(String[] args){
Demo2 d =new Demo2();
Thread t = new Thread(d);
t.start();
for(int x=0;x&60;x++){
System.out.println(Thread.currentThread().getName()+x);
class Demo2 implements Runnable{
public void run(){
for(int x=0;x&60;x++){
System.out.println(Thread.currentThread().getName()+x);
2.线程的生命周期
与人有生老病死一样，线程也同样要经历开始（等待）、运行、挂起和停止四种不同的状态。这四种状态都可以通过Thread类中的方法进行控制。下面给出了Thread类中和这四种状态相关的方法。
// 开始线程
publicvoid&start( );
publicvoid&run( );
// 挂起和唤醒线程
publicvoid&resume( );&&&&&// 不建议使用
publicvoid&suspend( );&&&&// 不建议使用
publicstaticvoid&sleep(long&millis);
publicstaticvoid&sleep(long&millis,&int&nanos);
// 终止线程
publicvoid&stop( );&&&&&&&// 不建议使用
publicvoid&interrupt( );
// 得到线程状态
publicboolean&isAlive( );
publicboolean&isInterrupted( );
publicstaticboolean&interrupted( );
// join方法
publicvoid&join( )&throws&InterruptedE
线程在建立后并不马上执行run方法中的代码，而是处于等待状态。线程处于等待状态时，可以通过Thread类的方法来设置线程不各种属性，如线程的优先级（setPriority）、线程名(setName)和线程的类型（setDaemon）等。
当调用start方法后，线程开始执行run方法中的代码。线程进入运行状态。可以通过Thread类的isAlive方法来判断线程是否处于运行状态。当线程处于运行状态时，isAlive返回true，当isAlive返回false时，可能线程处于等待状态，也可能处于停止状态。下面的代码演示了线程的创建、运行和停止三个状态之间的切换，并输出了相应的isAlive返回值。
一但线程开始执行run方法，就会一直到这个run方法执行完成这个线程才退出。但在线程执行的过程中，可以通过两个方法使线程暂时停止执行。这两个方法是suspend和sleep。在使用suspend挂起线程后，可以通过resume方法唤醒线程。而使用sleep使线程休眠后，只能在设定的时间后使线程处于就绪状态（在线程休眠结束后，线程不一定会马上执行，只是进入了就绪状态，等待着系统进行调度）。
在使用sleep方法时有两点需要注意：
1. sleep方法有两个重载形式，其中一个重载形式不仅可以设毫秒，而且还可以设纳秒(1,000,000纳秒等于1毫秒)。但大多数操作系统平台上的Java虚拟机都无法精确到纳秒，因此，如果对sleep设置了纳秒，Java虚拟机将取最接近这个值的毫秒。
2. 在使用sleep方法时必须使用throws或try{&}catch{&}。因为run方法无法使用throws，所以只能使用try{&}catch{&}。当在线程休眠的过程中，使用interrupt方法中断线程时sleep会抛出一个InterruptedException异常。sleep方法的定义如下：
publicstaticvoid&sleep(long&millis)&throws&InterruptedException
publicstaticvoid&sleep(long&millis,&int&nanos)&throws&InterruptedException
有三种方法可以使终止线程。
1.& 使用退出标志，使线程正常退出，也就是当run方法完成后线程终止。
2.& 使用stop方法强行终止线程（这个方法不推荐使用，因为stop和suspend、resume一样，也可能发生不可预料的结果）。
3.& 使用interrupt方法中断线程。
1. 使用退出标志终止线程
当run方法执行完后，线程就会退出。但有时run方法是永远不会结束的。如在服务端程序中使用线程进行监听客户端请求，或是其他的需要循环处理的任务。在这种情况下，一般是将这些任务放在一个循环中，如while循环。如果想让循环永远运行下去，可以使用while(true){&}来处理。但要想使while循环在某一特定条件下退出，最直接的方法就是设一个boolean类型的标志，并通过设置这个标志为true或false来控制while循环是否退出。下面给出了一个利用退出标志终止线程的例子。
join方法的功能就是使异步执行的线程变成同步执行。也就是说，当调用线程实例的start方法后，这个方法会立即返回，如果在调用start方法后后需要使用一个由这个线程计算得到的值，就必须使用join方法。如果不使用join方法，就不能保证当执行到start方法后面的某条语句时，这个线程一定会执行完。而使用join方法后，直到这个线程退出，程序才会往下执行。下面的代码演示了join的用法。
3.多线程安全问题
问题原因：当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没执行完，另一个线程参与进来执行，导致共享数据的错误。
解决办法：对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其他线程不执行。
同步代码块：
public class ThreadDemo3 {
public static void main(String[] args){
Ticket t =new Ticket();
Thread t1 = new Thread(t,&窗口一&);
Thread t2 = new Thread(t,&窗口二&);
Thread t3 = new Thread(t,&窗口三&);
Thread t4 = new Thread(t,&窗口四&);
t1.start();
t2.start();
t3.start();
t4.start();
class Ticket implements Runnable{
private int ticket =400;
public void run(){
while(true){
synchronized (new Object()) {
Thread.sleep(1);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
if(ticket&=0)
System.out.println(Thread.currentThread().getName()+&---卖出&+ticket--);
public class ThreadDemo3 {
public static void main(String[] args){
Ticket t =new Ticket();
Thread t1 = new Thread(t,&窗口一&);
Thread t2 = new Thread(t,&窗口二&);
Thread t3 = new Thread(t,&窗口三&);
Thread t4 = new Thread(t,&窗口四&);
t1.start();
t2.start();
t3.start();
t4.start();
class Ticket implements Runnable{
private int ticket = 4000;
public synchronized void
saleTicket(){
if(ticket&0)
System.out.println(Thread.currentThread().getName()+&卖出了&+ticket--);
public void run(){
while(true){
saleTicket();
同步函数锁是this 静态同步函数锁是class
线程间的通信
public class ThreadDemo3 {
public static void main(String[] args){
class Person{
public void set(String name,String gender){
this.name =
this.gender =
public void get(){
System.out.println(this.name+&....&+this.gender);
final Person p =new Person();
new Thread(new Runnable(){
public void run(){
while(true){
p.set(&张三&, &男&);
p.set(&lili&, &nv&);
x=(x+1)%2;
}).start();
new Thread(new Runnable(){
public void run(){
while(true){
}).start();
张三....男
张三....男
lili....nv
lili....男
张三....nv
lili....男
修改上面代码
public class ThreadDemo3 {
public static void main(String[] args){
class Person{
public void set(String name,String gender){
this.name =
this.gender =
public void get(){
System.out.println(this.name+&....&+this.gender);
final Person p =new Person();
new Thread(new Runnable(){
public void run(){
while(true){
synchronized (p) {
p.set(&张三&, &男&);
p.set(&lili&, &nv&);
x=(x+1)%2;
}).start();
new Thread(new Runnable(){
public void run(){
while(true){
synchronized (p) {
}).start();
lili....nv
lili....nv
lili....nv
lili....nv
lili....nv
lili....nv
张三....男
张三....男
张三....男
张三....男
等待唤醒机制
*线程等待唤醒机制
*等待和唤醒必须是同一把锁
public class ThreadDemo3 {
private static boolean flags =
public static void main(String[] args){
class Person{
public void set(String name,String gender){
this.name =
this.gender =
public void get(){
System.out.println(this.name+&....&+this.gender);
final Person p =new Person();
new Thread(new Runnable(){
public void run(){
while(true){
synchronized (p) {
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
p.set(&张三&, &男&);
p.set(&lili&, &nv&);
x=(x+1)%2;
p.notifyAll();
}).start();
new Thread(new Runnable(){
public void run(){
while(true){
synchronized (p) {
if(!flags)
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
p.notifyAll();
}).start();
生产消费机制一
public class ThreadDemo4 {
private static boolean flags =
public static void main(String[] args){
class Goods{
public synchronized void produce(String name){
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
this.name =name+&编号：&+num++;
System.out.println(&生产了....&+this.name);
notifyAll();
public synchronized void consume(){
if(!flags)
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println(&消费了******&+name);
notifyAll();
final Goods g =new Goods();
new Thread(new Runnable(){
public void run(){
while(true){
g.produce(&商品&);
}).start();
new Thread(new Runnable(){
public void run(){
while(true){
g.consume();
}).start();
生产消费机制2
public class ThreadDemo4 {
private static boolean flags =
public static void main(String[] args){
class Goods{
public synchronized void produce(String name){
while(flags)
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
this.name =name+&编号：&+num++;
System.out.println(Thread.currentThread().getName()+&生产了....&+this.name);
notifyAll();
public synchronized void consume(){
while(!flags)
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
System.out.println(Thread.currentThread().getName()+&消费了******&+name);
notifyAll();
final Goods g =new Goods();
new Thread(new Runnable(){
public void run(){
while(true){
g.produce(&商品&);
},&生产者一号&).start();
new Thread(new Runnable(){
public void run(){
while(true){
g.produce(&商品&);
},&生产者二号&).start();
new Thread(new Runnable(){
public void run(){
while(true){
g.consume();
},&消费者一号&).start();
new Thread(new Runnable(){
public void run(){
while(true){
g.consume();
},&消费者二号&).start();
消费者二号消费了******商品编号：48049
生产者一号生产了....商品编号：48050
消费者一号消费了******商品编号：48050
生产者一号生产了....商品编号：48051
消费者二号消费了******商品编号：48051
生产者二号生产了....商品编号：48052
消费者二号消费了******商品编号：48052
生产者一号生产了....商品编号：48053
消费者一号消费了******商品编号：48053
生产者一号生产了....商品编号：48054
消费者二号消费了******商品编号：48054
生产者二号生产了....商品编号：48055
消费者二号消费了******商品编号：48055
Java多线程的用法最全详解，以上就是对于java程序语言的简介，更多有关java方面的技术内容资讯，请继续关注拓胜科技，或者需要了解拓胜java培训的，可以在线咨询拓胜教育老师。
本文出自广州拓胜科技，转载请务必保留此出处，谢谢合作！
&拓胜愿景：自信成就好生活
&拓胜校训：勤奋、实践、自信、责任心
拓胜科技，是中国浸入式软件培训开山之祖，是中国"软件工厂"培训模式首创者。拓胜科技师资全部来自国际国内顶级软件设计专家，10年以上软件研发及管理经验。经过将近10年的发展，拓胜科技已经成为全国大学生高质素就业最可靠的导师和引路人。我们自2005年开始，为全国大学生提供最专业的java培训、android培训、ios培训、Uid培训、轻混合应用培训、软件测试培训及企业定制化培训。
下一篇：没有了
it培训专题
it培训频道
it培训就业
it培训技术
it培训课件
it培训开班
it培训师资