编写具有多线程能力的程序经常会用到的方法有:
run(),start(),wait(),notify(),notifyAll(),sleep(),yield(),join()
还有一个重要的关键字:synchronized
本文将对以上内容进行讲解。
一:run()和start()
示例1:
publicclassThreadTestextendsThread{
publicvoidrun(){
for(inti=0;i<10;i++){
System.out.print(""+i);
}
}
publicstaticvoidmain(String[]args){
newThreadTest().start();
newThreadTest().start();
}
}
这是个简单的多线程程序。run()和start()是大家都很熟悉的两个方法。把希望并行处理的代码都放在run()中;stat()用于自动调用run(),
这是JAVA的内在机制规定的。并且run()的访问控制符必须是public,返回值必须是void(这种说法不准确,run()没有返回值),run()
不带参数。
这些规定想必大家都早已知道了,但你是否清楚为什么run方法必须声明成这样的形式?这涉及到JAVA的方法覆盖和重载的规定。这些内容很重要,
请读者参考相关资料。
二:关键字synchronized
有了synchronized关键字,多线程程序的运行结果将变得可以控制。synchronized关键字用于保护共享数据。请大家注意"共享数据",
你一定要分清哪些数据是共享数据,JAVA是面向对象的程序设计语言,所以初学者在编写多线程程序时,容易分不清哪些数据是共享数据。请看下面的例子:
示例2:
publicclassThreadTestimplementsRunnable{
publicsynchronizedvoidrun(){
for(inti=0;i<10;i++){
System.out.print(""+i);
}
}
publicstaticvoidmain(String[]args){
Runnabler1=newThreadTest();
Runnabler2=newThreadTest();
Threadt1=newThread(r1);
Threadt2=newThread(r2);
t1.start();
t2.start();
}
}
在这个程序中,run()被加上了synchronized关键字。在main方法中创建了两个线程。你可能会认为此程序的运行结果一定为:0123456789
0123456789。但你错了!这个程序中synchronized关键字保护的不是共享数据(
其实在这个程序中synchronized关键字没有起到任何作用,此程序的运行结果是不可预先确定的)。这个程序中的t1,t2是两个对象(r1,
r2)的线程。JAVA是面向对象的程序设计语言,不同的对象的数据是不同的,r1,
r2有各自的run()方法,而synchronized使同一个对象的多个线程,
在某个时刻只有其中的一个线程可以访问这个对象的synchronized数据。每个对象都有一个"锁标志",
当这个对象的一个线程访问这个对象的某个synchronized数据时,这个对象的所有被synchronized修饰的数据将被上锁(因为"锁标志"
被当前线程拿走了),只有当前线程访问完它要访问的synchronized数据时,当前线程才会释放"锁标志",
这样同一个对象的其它线程才有机会访问synchronized数据。
示例3:
publicclassThreadTestimplementsRunnable{
publicsynchronizedvoidrun(){
for(inti=0;i<10;i++){
System.out.print(""+i);
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt1=newThread(r);
Threadt2=newThread(r);
t1.start();
t2.start();
}
}
如果你运行1000次这个程序,它的输出结果也一定每次都是:01234567890123456789。因为这里的synchronized保护的是共享数据。
t1,
t2是同一个对象(r)的两个线程,当其中的一个线程(例如:t1)开始执行run()方法时,由于run()受synchronized保护,所以同一个对象的其他线程(
t2)无法访问synchronized方法(run方法)。只有当t1执行完后t2才有机会执行。
示例4:
publicclassThreadTestimplementsRunnable{
publicvoidrun(){
synchronized(this){
for(inti=0;i<10;i++){
System.out.print(""+i);
}
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt1=newThread(r);
Threadt2=newThread(r);
t1.start();
t2.start();
}
}
这个程序与示例3的运行结果一样。在可能的情况下,应该把保护范围缩到最小,可以用示例4的形式,this代表"这个对象"。没有必要把整个run()保护起来,
run()中的代码只有一个for循环,所以只要保护for循环就可以了。
示例5:
publicclassThreadTestimplementsRunnable{
publicvoidrun(){
for(intk=0;k<5;k++){
System.out.println(Thread.currentThread().getName()
+":forloop:"+k);
}
synchronized(this){
for(intk=0;k<5;k++){
System.out.println(Thread.currentThread().getName()
+":synchronizedforloop:"+k);
}
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt1=newThread(r,"t1_name");
Threadt2=newThread(r,"t2_name");
t1.start();
t2.start();
}
}
运行结果:t1_name:forloop:0
t1_name:forloop:1
t1_name:forloop:2
t2_name:forloop:0
t1_name:forloop:3
t2_name:forloop:1
t1_name:forloop:4
t2_name:forloop:2
t1_name:synchronizedforloop:0
t2_name:forloop:3
t1_name:synchronizedforloop:1
t2_name:forloop:4
t1_name:synchronizedforloop:2
t1_name:synchronizedforloop:3
t1_name:synchronizedforloop:4
t2_name:synchronizedforloop:0
t2_name:synchronizedforloop:1
t2_name:synchronizedforloop:2
t2_name:synchronizedforloop:3
t2_name:synchronizedforloop:4
第一个for循环没有受synchronized保护。对于第一个for循环,t1,
t2可以同时访问。运行结果表明t1执行到了k=2时,t2开始执行了。t1首先执行完了第一个for循环,此时还没有执行完第一个for循环(
t2刚执行到k=2)。t1开始执行第二个for循环,当t1的第二个for循环执行到k=1时,t2的第一个for循环执行完了。
t2想开始执行第二个for循环,但由于t1首先执行了第二个for循环,这个对象的锁标志自然在t1手中(
synchronized方法的执行权也就落到了t1手中),在t1没执行完第二个for循环的时候,它是不会释放锁标志的。
所以t2必须等到t1执行完第二个for循环后,它才可以执行第二个for循环
三:sleep()
示例6:
publicclassThreadTestimplementsRunnable{
publicvoidrun(){
for(intk=0;k<5;k++){
if(k==2){
try{
Thread.currentThread().sleep(5000);
}
catch(Exceptione){}
}
System.out.print(""+k);
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt=newThread(r);
t.start();
}
}
sleep方法会使当前的线程暂停执行一定时间(给其它线程运行机会)。读者可以运行示例6,看看结果就明白了。sleep方法会抛出异常,必须提供捕获代码。
示例7:
publicclassThreadTestimplementsRunnable{
publicvoidrun(){
for(intk=0;k<5;k++){
if(k==2){
try{
Thread.currentThread().sleep(5000);
}
catch(Exceptione){}
}
System.out.println(Thread.currentThread().getName()
+":"+k);
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt1=newThread(r,"t1_name");
Threadt2=newThread(r,"t2_name");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
t1被设置了最高的优先级,t2被设置了最低的优先级。t1不执行完,t2就没有机会执行。但由于t1在执行的中途休息了5秒中,这使得t2就有机会执行了。
读者可以运行这个程序试试看。
示例8:
publicclassThreadTestimplementsRunnable{
publicsynchronizedvoidrun(){
for(intk=0;k<5;k++){
if(k==2){
try{
Thread.currentThread().sleep(5000);
}
catch(Exceptione){}
}
System.out.println(Thread.currentThread().getName()
+":"+k);
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt1=newThread(r,"t1_name");
Threadt2=newThread(r,"t2_name");
t1.start();
t2.start();
}
}
请读者首先运行示例8程序,从运行结果上看:一个线程在sleep的时候,并不会释放这个对象的锁标志。
四:join()
示例9:
publicclassThreadTestimplementsRunnable{
publicstaticinta=0;
publicvoidrun(){
for(intk=0;k<5;k++){
a=a+1;
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt=newThread(r);
t.start();
System.out.println(a);
}
}
请问程序的输出结果是5吗?答案是:有可能。其实你很难遇到输出5的时候,通常情况下都不是5。这里不讲解为什么输出结果不是5,我要讲的是:
怎样才能让输出结果为5!其实很简单,join()方法提供了这种功能。join()方法,它能够使调用该方法的线程在此之前执行完毕。
把示例9的main()方法该成如下这样:
publicstaticvoidmain(String[]args)throwsException{
Runnabler=newThreadTest();
Threadt=newThread(r);
t.start();
t.join();
System.out.println(a);
}
这时,输出结果肯定是5!join()方法会抛出异常,应该提供捕获代码。或留给JDK捕获。
示例10:
publicclassThreadTestimplementsRunnable{
publicvoidrun(){
for(intk=0;k<10;k++){
System.out.print(""+k);
}
}
publicstaticvoidmain(String[]args)throwsException{
Runnabler=newThreadTest();
Threadt1=newThread(r);
Threadt2=newThread(r);
t1.start();
t1.join();
t2.start();
}
}
运行这个程序,看看结果是否与示例3一样
五:yield()
yield()方法与sleep()方法相似,只是它不能由用户指定线程暂停多长时间。按照SUN的说法:
sleep方法可以使低优先级的线程得到执行的机会,当然也可以让同优先级和高优先级的线程有执行的机会。而yield()
方法只能使同优先级的线程有执行的机会。
示例11:
publicclassThreadTestimplementsRunnable{
publicvoidrun(){
8
for(intk=0;k<10;k++){
if(k==5&&Thread.currentThread().getName().equals("t1")){
Thread.yield();
}
System.out.println(Thread.currentThread().getName()
+":"+k);
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt1=newThread(r,"t1");
Threadt2=newThread(r,"t2");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}
输出结果:
t1:0
t1:1
t1:2
t1:3
t1:4
t1:5
t1:6
t1:7
t1:8
t1:9
t2:0
t2:1
t2:2
t2:3
t2:4
t2:5
t2:6
t2:7
t2:8
t2:9
多次运行这个程序,输出也是一样。这说明:yield()方法不会使不同优先级的线程有执行的机会。
六:wait(),notify(),notifyAll()
首先说明:wait(),notify(),
notifyAll()这些方法由java.lang.Object类提供,而上面讲到的方法都是由java.lang.Thread类提供(
Thread类实现了Runnable接口)。
wait(),notify(),
notifyAll()这三个方法用于协调多个线程对共享数据的存取,所以必须在synchronized语句块内使用这三个方法。先看下面了例子:
示例12:
publicclassThreadTestimplementsRunnable{
publicstaticintshareVar=0;
publicsynchronizedvoidrun(){
if(shareVar==0){
for(inti=0;i<10;i++){
shareVar++;
if(shareVar==5){
try{
this.wait();
}
catch(Exceptione){}
}
}
}
if(shareVar!=0){
System.out.print(Thread.currentThread().getName());
System.out.println("shareVar="+shareVar);
this.notify();
}
}
publicstaticvoidmain(String[]args){
Runnabler=newThreadTest();
Threadt1=newThread(r,"t1");
10
Threadt2=newThread(r,"t2");
t1.start();
t2.start();
}
}
运行结果:
t2shareVar=5
t1shareVar=10
t1线程最先执行。由于初始状态下shareVar为0,t1将使shareVar连续加1,当shareVar的值为5时,t1调用wait()方法,
t1将处于休息状态,同时释放锁标志。这时t2得到了锁标志开始执行,shareVar的值已经变为5,所以t2直接输出shareVar的值,
然后再调用notify()方法唤醒t1。t1接着上次休息前的进度继续执行,把shareVar的值一直加到10,由于此刻shareVar的值不为0,
所以t1将输出此刻shareVar的值,然后再调用notify()方法,由于此刻已经没有等待锁标志的线程,所以此调用语句不起任何作用。
这个程序简单的示范了wait(),notify()的用法,读者还需要在实践中继续摸索。
七:关于线程的补充
编写一个具有多线程能力的程序可以继承Thread类,也可以实现Runnable接口。在这两个方法中如何选择呢?从面向对象的角度考虑,
作者建议你实现Runnable接口。有时你也必须实现Runnable接口,例如当你编写具有多线程能力的小应用程序的时候。
线程的调度:NewRunningRunnableOtherwiseBlockedDeadBlockedinobject`sit()
poolBlockedinobject`slockpoolnotify()Schedulercompletesrun()start()
sleep()orjoin()sleep()timeoutorthreadjoin()sorinterupt()
Lockavailablesynchronized()Threadstates
terupt()一个Thread对象在它的生命周期中会处于各种不同的状态,上图形象地说明了这点。wain
调用start()方法使线程处于可运行状态,这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。
实际上,程序中的多个线程并不是同时执行的。除非线程正在真正的多CPU计算机系统上执行,否则线程使用单CPU必须轮流执行。但是,由于这发生的很快,
我们常常认为这些线程是同时执行的。
JAVA运行时系统的计划调度程序是抢占性的。如果计划调度程序正在运行一个线程并且来了另一个优先级更高的线程,
那么当前正在执行的线程就被暂时终止而让更高优先级的线程执行。
JAVA计划调度程序不会为与当前线程具有同样优先级的另一个线程去抢占当前的线程。但是,尽管计划调度程序本身没有时间片(
即它没有给相同优先级的线程以执行用的时间片),但以Thread类为基础的线程的系统实现可能会支持时间片分配。这依赖具体的操作系统,
Windows与UNIX在这个问题上的支持不会完全一样。
由于你不能肯定小应用程序将运行在什么操作系统上,因此你不应该编写出依赖时间片分配的程序。就是说,
应该使用yield方法以允许相同优先级的线程有机会执行而不是希望每一个线程都自动得到一段CPU时间片。
Thread类提供给你与系统无关的处理线程的机制。但是,线程的实际实现取决于JAVA运行所在的操作系统。因此,
线程化的程序确实是利用了支持线程的操作系统。
当创建线程时,可以赋予它优先级。它的优先级越高,它就越能影响运行系统。
JAVA运行系统使用一个负责在所有执行JAVA程序内运行所有存在的计划调度程序。
该计划调度程序实际上使用一个固定优先级的算法来保证每个程序中的最高优先级的线程得到CPU--允许最高优先级的线程在其它线程之前执行。
对于在一个程序中有几个相同优先级的线程等待执行的情况,该计划调度程序循环地选择它们,当进行下一次选择时选择前面没有执行的线程,
具有相同优先级的所有的线程都受到平等的对待。较低优先级的线程在较高优先级的线程已经死亡或者进入不可执行状态之后才能执行。
继续讨论wait(),notify(),notifyAll():
当线程执行了对一个特定对象的wait()调用时,那个线程被放到与那个对象相关的等待池中。此外,调用wait()的线程自动释放对象的锁标志。
可以调用不同的wait():wait()或wait(longtimeout)
对一个特定对象执行notify()调用时,将从对象的等待池中移走一个任意的线程,并放到锁标志等待池中,那里的线程一直在等待,
直到可以获得对象的锁标志。notifyAll()方法将从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。
只有锁标志等待池中的线程能获取对象的锁标志,锁标志允许线程从上次因调用wait()而中断的地方开始继续运行。
在许多实现了wait()/notify()机制的系统中,醒来的线程必定是那个等待时间最长的线程。然而,在Java技术中,并不保证这点。
注意,不管是否有线程在等待,都可以调用notify()。如果对一个对象调用notify()方法,而在这个对象的锁标志等待池中并没有线程,
那么notify()调用将不起任何作用。
在JAVA中,多线程是一个神奇的主题。之所以说它"神奇",是因为多线程程序的运行结果不可预测,但我们又可以通过某些方法控制多线程程序的执行。
要想灵活使用多线程,读者还需要大量实践。
另外,从JDK1.2开始,SUN就不建议使用resume(),stop(),suspend()了
分享到:
相关推荐
Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式上传文件Java多线程设计模式...
### Java多线程操作数据库:深入解析与应用 在当今高度并发的应用环境中,Java多线程技术被广泛应用于处理数据库操作,以提升系统的响应速度和处理能力。本文将基于一个具体的Java多线程操作数据库的应用程序,深入...
Java多线程读大文件 java多线程写文件:多线程往队列中写入数据
java多线程PPT 多线程基本概念 创建线程的方式 线程的挂起与唤醒 多线程问题
Java多线程是Java编程语言中一个非常重要的概念,它允许开发者在一个程序中创建多个执行线程并行运行,以提高程序的执行效率和响应速度。在Java中,线程的生命周期包含五个基本状态,分别是新建状态(New)、就绪...
Java多线程是Java编程中的重要概念,尤其在如今的多核处理器环境下,理解并熟练掌握多线程技术对于提高程序性能和响应速度至关重要。本资料详细讲解了Java多线程的原理,并提供了丰富的实战代码,非常适合Java初学者...
Java多线程是Java编程中的重要概念,它允许程序同时执行多个任务,极大地提升了程序的效率和性能。在Java中,实现多线程有两种主要方式:通过实现Runnable接口或者继承Thread类。本案例将深入探讨Java多线程中的关键...
Java多线程是Java编程中的一个重要概念,它允许程序同时执行多个任务,提高了程序的效率和响应速度。在Java中,实现多线程有两种主要方式:继承Thread类和实现Runnable接口。 1. 继承Thread类: 当我们创建一个新...
### Java多线程分页查询知识点详解 #### 一、背景与需求分析 在实际的软件开发过程中,尤其是在处理大量数据时,如何高效地进行数据查询成为了一个关键问题。例如,在一个用户众多的社交平台上,当用户需要查看...
在Java编程中,多线程处理是提升程序性能和效率的重要手段,特别是在处理大量数据库数据时。本主题将深入探讨如何使用Java的并发包(java.util.concurrent)来实现多线程对数据库数据的批量处理,包括增、删、改等...
综上所述,"java多线程查询数据库"是一个涉及多线程技术、线程池管理、并发控制、分页查询等多个方面的复杂问题。通过理解和掌握这些知识点,我们可以有效地提高数据库操作的效率和系统的响应速度。
在Java编程中,多线程并发是提升程序执行效率、充分利用多核处理器资源的重要手段。本文将基于"java 多线程并发实例"这个主题,深入探讨Java中的多线程并发概念及其应用。 首先,我们要了解Java中的线程。线程是...
在本文中,我们将深入浅出Java多线程编程的世界,探索多线程编程的基本概念、多线程编程的优点、多线程编程的缺点、多线程编程的应用场景、多线程编程的实现方法等内容。 一、多线程编程的基本概念 多线程编程是指...
《JAVA多线程教学演示系统》是一篇深入探讨JAVA多线程编程的论文,它针对教育领域中的教学需求,提供了一种生动、直观的演示方式,帮助学生更好地理解和掌握多线程技术。这篇论文的核心内容可能包括以下几个方面: ...
《汪文君JAVA多线程编程实战》是一本专注于Java多线程编程的实战教程,由知名讲师汪文君倾力打造。这本书旨在帮助Java开发者深入理解和熟练掌握多线程编程技术,提升软件开发的效率和质量。在Java平台中,多线程是...
### JAVA中的单线程与多线程概念解析 #### 单线程的理解 在Java编程环境中,单线程指的是程序执行过程中只有一个线程在运行。这意味着任何时刻只能执行一个任务,上一个任务完成后才会进行下一个任务。单线程模型...
JAVA多线程练习题答案详解 在本文中,我们将对 JAVA 多线程练习题的答案进行详细的解释和分析。这些题目涵盖了 JAVA 多线程编程的基本概念和技术,包括线程的生命周期、线程同步、线程状态、线程优先级、线程安全等...
这份“JAVA多线程编程技术PDF”是学习和掌握这一领域的经典资料,涵盖了多线程的全部知识点。 首先,多线程的核心概念包括线程的创建与启动。在Java中,可以通过实现Runnable接口或继承Thread类来创建线程。创建后...
Java多线程编程实战指南(核心篇) 高清pdf带目录 随着现代处理器的生产工艺从提升处理器主频频率转向多核化,即在一块芯片上集成多个处理器内核(Core),多核处理器(Multicore Processor)离我们越来越近了――如今...
本项目以"java多线程实现大批量数据导入源码"为题,旨在通过多线程策略将大量数据切分,并进行并行处理,以提高数据处理速度。 首先,我们需要理解Java中的线程机制。Java通过`Thread`类来创建和管理线程。每个线程...