JAVA技术专题综述之线程篇(1)

本文详细介绍JAVA技术专题综述之线程篇

编写具有多线程能力的程序经常会用到的方法有:

run(),start(),wait(),notify(),notifyAll(),sleep(),yield(),join()

还有一个重要的关键字:synchronized

本文将对以上内容进行讲解。

一:run()和start()

示例1:

public cla ThreadTest extends Thread
{
public void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
new ThreadTest().start();
new ThreadTest().start();
}
}

这是个简单的多线程程序。run()和start()是大家都很熟悉的两个方法。把希望并行处理的代码都放在run()中;stat()用于自动调用run(),这是JAVA的内在机制规定的。并且run()的访问控制符必须是public,返回值必须是void(这种说法不准确,run()没有返回值),run()不带参数。

这些规定想必大家都早已知道了,但你是否清楚为什么run方法必须声明成这样的形式?这涉及到JAVA的方法覆盖和重载的规定。这些内容很重要,请读者参考相关资料。

二:关键字synchronized

有了synchronized关键字,多线程程序的运行结果将变得可以控制。synchronized关键字用于保护共享数据。请大家注意"共享数据",你一定要分清哪些数据是共享数据,JAVA是面向对象的程序设计语言,所以初学者在编写多线程程序时,容易分不清哪些数据是共享数据。请看下面的例子:

示例2:

public cla ThreadTest implements Ruable
{
public synchronized void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
Ruable r1 = new ThreadTest();
Ruable r2 = new ThreadTest();
Thread t1 = new Thread(r1);
Thread t2 = new Thread(r2);
t1.start();
t2.start();
}
}

在这个程序中,run()被加上了synchronized关键字。在main方法中创建了两个线程。你可能会认为此程序的运行结果一定为:0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。但你错了!这个程序中synchronized关键字保护的不是共享数据(其实在这个程序中synchronized关键字没有起到任何作用,此程序的运行结果是不可预先确定的)。这个程序中的t1,t2是两个对象(r1,r2)的线程。JAVA是面向对象的程序设计语言,不同的对象的数据是不同的,r1,r2有各自的run()方法,而synchronized使同一个对象的多个线程,在某个时刻只有其中的一个线程可以访问这个对象的synchronized数据。每个对象都有一个"锁标志",当这个对象的一个线程访问这个对象的某个synchronized数据时,这个对象的所有被synchronized修饰的数据将被上锁(因为"锁标志"被当前线程拿走了),只有当前线程访问完它要访问的synchronized数据时,当前线程才会释放"锁标志",这样同一个对象的其它线程才有机会访问synchronized数据。

关键字: DbUnit 单元测试过程 持续集成 Maven XQuery 动态编译

本文详细介绍JAVA技术专题综述之线程篇

示例3:

public cla ThreadTest implements Ruable
{
public synchronized void run()
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}

如果你运行1000次这个程序,它的输出结果也一定每次都是:0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9。因为这里的synchronized保护的是共享数据。t1,t2是同一个对象(r)的两个线程,当其中的一个线程(例如:t1)开始执行run()方法时,由于run()受synchronized保护,所以同一个对象的其他线程(t2)无法访问synchronized方法(run方法)。只有当t1执行完后t2才有机会执行。

示例4:

public cla ThreadTest implements Ruable
{
public void run()
{
synchronized(this)
{
for(int i=0;i<10;i++)
{
System.out.print(" " + i);
}
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t2.start();
}
}

这个程序与示例3的运行结果一样。在可能的情况下,应该把保护范围缩到最小,可以用示例4的形式,this代表"这个对象"。没有必要把整个run()保护起来,run()中的代码只有一个for循环,所以只要保护for循环就可以了。

关键字: DbUnit 单元测试过程 持续集成 Maven XQuery 动态编译

本文详细介绍JAVA技术专题综述之线程篇

示例5:

public cla ThreadTest implements Ruable
{
public void run()
{
for(int k=0;k<5;k++)
{
System.out.println(Thread.currentThread().getName()
+ " : for loop : " + k);
}
synchronized(this)
{
for(int k=0;k<5;k++)
{
System.out.println(Thread.currentThread().getName()
+ " : synchronized for loop : " + k);
}
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.start();
t2.start();
}
}
运行结果: t1_name : for loop : 0
t1_name : for loop : 1
t1_name : for loop : 2
t2_name : for loop : 0
t1_name : for loop : 3
t2_name : for loop : 1
t1_name : for loop : 4
t2_name : for loop : 2
t1_name : synchronized for loop : 0
t2_name : for loop : 3
t1_name : synchronized for loop : 1
t2_name : for loop : 4
t1_name : synchronized for loop : 2
t1_name : synchronized for loop : 3
t1_name : synchronized for loop : 4
t2_name : synchronized for loop : 0
t2_name : synchronized for loop : 1
t2_name : synchronized for loop : 2
t2_name : synchronized for loop : 3
t2_name : synchronized for loop : 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循环。

关键字: DbUnit 单元测试过程 持续集成 Maven XQuery 动态编译

本文详细介绍JAVA技术专题综述之线程篇

三:sleep()

示例6:

public cla ThreadTest implements Ruable
{
public void run()
{
for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{}
}
System.out.print(" " + k);
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
}
}

sleep方法会使当前的线程暂停执行一定时间(给其它线程运行机会)。读者可以运行示例6,看看结果就明白了。sleep方法会抛出异常,必须提供捕获代码。

示例7:

public cla ThreadTest implements Ruable
{
public void run()
{
for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{}
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.setPriority(Thread.MAX_PRIORITY);
t2.setPriority(Thread.MIN_PRIORITY);
t1.start();
t2.start();
}
}

t1被设置了最高的优先级,t2被设置了最低的优先级。t1不执行完,t2就没有机会执行。但由于t1在执行的中途休息了5秒中,这使得t2就有机会执行了。读者可以运行这个程序试试看。

关键字: DbUnit 单元测试过程 持续集成 Maven XQuery 动态编译

本文详细介绍JAVA技术专题综述之线程篇

示例8:

public cla ThreadTest implements Ruable
{
public synchronized void run()
{
for(int k=0;k<5;k++)
{
if(k == 2)
{
try
{
Thread.currentThread().sleep(5000);
}
catch(Exception e)
{}
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t1 = new Thread(r,"t1_name");
Thread t2 = new Thread(r,"t2_name");
t1.start();
t2.start();
}
}

请读者首先运行示例8程序,从运行结果上看:一个线程在sleep的时候,并不会释放这个对象的锁标志。

四:join()

示例9:

public cla ThreadTest implements Ruable
{
public static int a = 0;
public void run()
{
for(int k=0;k<5;k++)
{
a = a + 1;
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
System.out.println(a);
}
}

请问程序的输出结果是5吗?答案是:有可能。其实你很难遇到输出5的时候,通常情况下都不是5。这里不讲解为什么输出结果不是5,我要讲的是:怎样才能让输出结果为5!其实很简单,join()方法提供了这种功能。join()方法,它能够使调用该方法的线程在此之前执行完毕。

把示例9的main()方法该成如下这样:

关键字: DbUnit 单元测试过程 持续集成 Maven XQuery 动态编译

本文详细介绍JAVA技术专题综述之线程篇

public static void main(String[] args) throws Exception
{
Ruable r = new ThreadTest();
Thread t = new Thread(r);
t.start();
t.join();
System.out.println(a);
}

这时,输出结果肯定是5!join()方法会抛出异常,应该提供捕获代码。或留给JDK捕获。

示例10:

public cla ThreadTest implements Ruable
{
public void run()
{
for(int k=0;k<10;k++)
{
System.out.print(" " + k);
}
}
public static void main(String[] args) throws Exception
{
Ruable r = new ThreadTest();
Thread t1 = new Thread(r);
Thread t2 = new Thread(r);
t1.start();
t1.join();
t2.start();
}
}

运行这个程序,看看结果是否与示例3一样?

五:yield()

yield()方法与sleep()方法相似,只是它不能由用户指定线程暂停多长时间。按照SUN的说法:sleep方法可以使低优先级的线程得到执行的机会,当然也可以让同优先级和高优先级的线程有执行的机会。而yield()方法只能使同优先级的线程有执行的机会。

示例11:

public cla ThreadTest implements Ruable
{
public void run()
{
8
for(int k=0;k<10;k++)
{
if(k == 5 &amam Thread.currentThread().getName().equals("t1"))
{
Thread.yield();
}
System.out.println(Thread.currentThread().getName()
+ " : " + k);
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t1 = new Thread(r,"t1");
Thread t2 = new Thread(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()方法不会使不同优先级的线程有执行的机会。

关键字: DbUnit 单元测试过程 持续集成 Maven XQuery 动态编译

本文详细介绍JAVA技术专题综述之线程篇

六:wait(),notify(),notifyAll()

首先说明:wait(),notify(),notifyAll()这些方法由java.lang.Object类提供,而上面讲到的方法都是由java.lang.Thread类提供(Thread类实现了Ruable接口)。

wait(),notify(),notifyAll()这三个方法用于协调多个线程对共享数据的存取,所以必须在synchronized语句块内使用这三个方法。先看下面了例子:

示例12:

public cla ThreadTest implements Ruable
{
public static int shareVar = 0;
public synchronized void run()
{
if(shareVar == 0)
{
for(int i=0;i<10;i++)
{
shareVar++ ;
if(shareVar == 5)
{
try
{
this.wait();
}
catch(Exception e)
{}
}
}
}
if(shareVar != 0)
{
System.out.print(Thread.currentThread().getName());
System.out.println(" shareVar = " + shareVar);
this.notify();
}
}
public static void main(String[] args)
{
Ruable r = new ThreadTest();
Thread t1 = new Thread(r,"t1");
10
Thread t2 = new Thread(r,"t2");
t1.start();
t2.start();
}
}
运行结果:
t2 shareVar = 5
t1 shareVar = 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()方法,由于此刻已经没有等待锁标志的线程,所以此调用语句不起任何作用。

关键字: DbUnit 单元测试过程 持续集成 Maven XQuery 动态编译

本文详细介绍JAVA技术专题综述之线程篇

这个程序简单的示范了wait(),notify()的用法,读者还需要在实践中继续摸索。

七:关于线程的补充

编写一个具有多线程能力的程序可以继承Thread类,也可以实现Ruable接口。在这两个方法中如何选择呢?从面向对象的角度考虑,作者建议你实现Ruable接口。有时你也必须实现Ruable接口,例如当你编写具有多线程能力的小应用程序的时候。

线程的调度: NewRuingRuableOtherwise BlockedDeadBlocked in object`sit()poolBlocked in object`slock poolnotify()Schedulercompletesrun()start()sleep() or join()sleep() timeout or thread join()s or interupt()Lockavailablesynchronized()Thread states

terupt()一个Thread对象在它的生命周期中会处于各种不同的状态,上图形象地说明了这点。wa in

调用start()方法使线程处于可运行状态,这意味着它可以由JVM调度并执行。这并不意味着线程就会立即运行。

实际上,程序中的多个线程并不是同时执行的。除非线程正在真正的多CPU计算机系统上执行,否则线程使用单CPU必须轮流执行。但是,由于这发生的很快,我们常常认为这些线程是同时执行的。

JAVA运行时系统的计划调度程序是抢占性的。如果计划调度程序正在运行一个线程并且来了另一个优先级更高的线程,那么当前正在执行的线程就被暂时终止而让更高优先级的线程执行。

JAVA计划调度程序不会为与当前线程具有同样优先级的另一个线程去抢占当前的线程。但是,尽管计划调度程序本身没有时间片(即它没有给相同优先级的线程以执行用的时间片),但以Thread类为基础的线程的系统实现可能会支持时间片分配。这依赖具体的操作系统,Windows与UNIX在这个问题上的支持不会完全一样。

关键字: DbUnit 单元测试过程 持续集成 Maven XQuery 动态编译

本文详细介绍JAVA技术专题综述之线程篇

由于你不能肯定小应用程序将运行在什么操作系统上,因此你不应该编写出依赖时间片分配的程序。就是说,应该使用yield方法以允许相同优先级的线程有机会执行而不是希望每一个线程都自动得到一段CPU时间片。

Thread类提供给你与系统无关的处理线程的机制。但是,线程的实际实现取决于JAVA运行所在的操作系统。因此,线程化的程序确实是利用了支持线程的操作系统。

当创建线程时,可以赋予它优先级。它的优先级越高,它就越能影响运行系统。JAVA运行系统使用一个负责在所有执行JAVA程序内运行所有存在的计划调度程序。该计划调度程序实际上使用一个固定优先级的算法来保证每个程序中的最高优先级的线程得到CPU--允许最高优先级的线程在其它线程之前执行。

对于在一个程序中有几个相同优先级的线程等待执行的情况,该计划调度程序循环地选择它们,当进行下一次选择时选择前面没有执行的线程,具有相同优先级的所有的线程都受到平等的对待。较低优先级的线程在较高优先级的线程已经死亡或者进入不可执行状态之后才能执行。

继续讨论wait(),notify(),notifyAll():

当线程执行了对一个特定对象的wait()调用时,那个线程被放到与那个对象相关的等待池中。此外,调用wait()的线程自动释放对象的锁标志。

可以调用不同的wait():wait() 或wait(long timeout)

对一个特定对象执行notify()调用时,将从对象的等待池中移走一个任意的线程,并放到锁标志等待池中,那里的线程一直在等待,直到可以获得对象的锁标志。notifyAll()方法将从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。只有锁标志等待池中的线程能获取对象的锁标志,锁标志允许线程从上次因调用wait()而中断的地方开始继续运行。

在许多实现了wait()/notify()机制的系统中,醒来的线程必定是那个等待时间最长的线程。然而,在Java技术中,并不保证这点。

注意,不管是否有线程在等待,都可以调用notify()。如果对一个对象调用notify()方法,而在这个对象的锁标志等待池中并没有线程,那么notify()调用将不起任何作用。

在JAVA中,多线程是一个神奇的主题。之所以说它"神奇",是因为多线程程序的运行结果不可预测,但我们又可以通过某些方法控制多线程程序的执行。要想灵活使用多线程,读者还需要大量实践。

另外,从JDK 1.2开始,SUN就不建议使用resume(),stop(),suend()了。

http://www.jisu3d.com/2010/0525/16637.html

时间: 2024-10-02 02:43:28

JAVA技术专题综述之线程篇(1)的相关文章

【Java】Java XML 技术专题

XML 基础教程 XML 和 Java 技术 Java XML文档模型 JAXP(Java API for XML Parsing) StAX(Streaming API for XML) XJ(XML Enhancements for Java) XML 验证 XPath XQuery XSL 转换处理器 XStream 数据绑定 本专题汇总了大量面向 Java 开发人员的 XML 技术文章和教程,内容涉及 XML 基础.Java XML 的文档模型.编程 API 与数据绑定框架以及 Java

最值得收藏的java技术博客(Java篇)

第一个:java_my_life 作者介绍:找不到原作者信息.大概做了翻阅全部是2012年的博客. 博客主要内容:主要内容是关于Java设计模式的一些讲解和学习笔记,在相信对学习设计模式的同学帮助很大.在一望无际的Java博文中有那么一两篇JavaScript文章,就算两篇Javascript的质量不是很高,其它教程也是能很好的帮助到在学习中的朋友. 博客关键词:JAVA与模式.简单工厂模式.工厂方法.抽象工厂.单例.建造.原型.适配器.合成.迭代.观察者.模板方法.策略.不变.桥梁.门面.代理

Java图像处理最快技术:ImageJ 学习第一篇

ImageJ是世界上最快的纯Java的图像处理程序.它可以过滤一个2048x2048的图像在0.1秒内(*).这是每秒40万像素!ImageJ的扩展通过使用内置的文本编辑器和Java编译器的ImageJ的开发插件.500多插件可用. 数据类型:8位灰度或索引色,16位无符号整数,32位浮点和RGB色彩. 文件格式:读写所有支持的数据类型为TIFF(非压缩)或原始数据.打开和保存GIF,JPEG,BMP,PNG,PGM,FITS和ASCII.打开DICOM.使用URL打开的TIFF.GIF文件.J

C++技术问题总结-第3篇 线程同步

线程同步的方法 线程同步有多种方法. 用户模式下的线程同步:关键段(critcal section). 内核模式下的线程同步:事件.计时器.信号量.互斥量. 1.关键段 用户模式下的同步,主要API如下. InitializeCriticalSection.DeleteCriticalSection.EnterCriticalSection.LeaveCriticalSection. 2.事件 常用于:一个线程初始化工作,然后再触发另一个线程让它工作.主要API如下. CreateEvent.S

Java技术综述

自己打算好好学习下Java,所以想先明晰Java开发中到底有哪些技术,以便以后学习的过程中,可以循序渐进,随着学习的深入,本文将不断更新. Java基础教程将Java的入门基础知识贯穿在一个实例中,逐步深入,可以帮助你快速进入Java编程的世界.万事开头难,逐步跟着这个教程走一遍,对Java应该就会有一种入门的感觉了.然后再去学习更高级的主题,或者更深入地学习其中的某些知识点. 首先学习Java的一些基础知识,包括: Java开发环境安装与配置 Eclipse的安装与使用 面向对象基础 基本数据

Java中的进程与线程(总结篇)

详细文档: Java中的进程与线程.rar 474KB 1/7/2017 6:21:15 PM 概述: 几乎任何的操作系统都支持运行多个任务,通常一个任务就是一个程序,而一个程序就是一个进程.当一个进程运行时,内部可能包括多个顺序执行流,每个顺序执行流就是一个线程. 进程与线程: 进程是指处于运行过程中的程序,并且具有一定的独立功能.进程是系统进行资源分配和调度的一个单位.当程序进入内存运行时,即为线程. 进程拥有以下三个特点: 1:独立性:进程是系统中独立存在的实体,它可以独立拥有资源,每一个

Java工程师学习指南(中级篇)

Java工程师学习指南 中级篇 最近有很多小伙伴来问我,Java小白如何入门,如何安排学习路线,每一步应该怎么走比较好.原本我以为之前的几篇文章已经可以解决大家的问题了,其实不然,因为我写的文章都是站在Java后端的全局上进行思考和总结的,忽略了很多小白们的感受,而很多朋友都需要更加基础,更加详细的学习路线. 所以,今天我们重新开一个新的专题,分别按照四个部分讲述Java的学习路线,笔者也打算趁此机会,回忆一下自己的Java学习历程.今天我们要讲的是第三部分,Java工程师学习指南(中级篇).

.NET C#到Java没那么难,Servlet篇

前言 .NET C#到Java没那么难,都是面向对向的语言,而且语法还是相似的,先对比一下开发环境,再到Servlet,再到MVC,都是一样一样的,只是JAVA的配制项比较多而已,只要配好一个,后面都是copy,简直so easy,而且用myeclipse可以省一些配制 Java与.NET的区别不在它们的本身,最大的区别在于他们背后的力量,相信大家都能感觉得到,我就不多说. 目录 一..NET C#到Java没那么难,开发环境篇 二..NET C#到Java没那么难,Servlet篇 三..NE

Java技术体系大全,准备面试的可以参考一下!

1. JAVA技术体系1.1 Java程序员 ·高级特性 反射.泛型.注释符.自动装箱和拆箱.枚举类.可变参数.可变返回类型.增强循环.静态导入 ·核心编程 IO.多线程.实体类.集合类.正则表达式.XML和属性文件 ·图形编程 AWT(Java2D/JavaSound/JMF).Swing.SWT.JFace ·网路编程 Applet.Socket/TCP/UDP.NIO.RMI.CORBA ·Java语法基础 类.抽象类.接口.最终类.静态类.匿名类.内部类.异常类.编码规范 ·Java开发