2022年JAVA多线程教程 .pdf

《2022年JAVA多线程教程 .pdf》由会员分享，可在线阅读，更多相关《2022年JAVA多线程教程 .pdf（17页珍藏版）》请在淘文阁 - 分享文档赚钱的网站上搜索。

1、JAVA 多线程教程-杭州三部：王飞开发过程碰到多线程相关的问题，中心内部没有相关的资料和范例，只好找回大学的知识，磕磕绊绊，开发成功。总结经验教训，整理出此教程。与大家分享。首先，虽然操作系统是多线程的，java 程序是多线程的，但一个CPU 每一时刻只能做一件事。【引言：】此为引言，可以跳过。总的来说：1，多线程的目的是为了最大限度的利用CPU 资源。2，对于一个进程中的多个线程来说，多个线程共享进程的内存块，当有新的线程产生的时候，操作系统不分配新的内存，而是让新线程共享原有的进程块的内存。3，操作的系统的多进程实现了多任务并发执行，程序的多线程实现了进程的并发执行。多任务、多进程、多线

2、程的前提都是要求操作系统提供多任务、多进程、多线程的支持。-随着计算机的飞速发展，个人计算机上的操作系统也纷纷采用多任务和分时设计，将早期只有大型计算机才具有的系统特性带到了个人计算机系统中。一般可以在同一时间内执行多个程序的操作系统都有进程的概念。一个进程就是一个执行中的程序，而每一个进程都有自己独立的一块内存空间、一组系统资源。在进程概念中，每一个进程的内部数据和状态都是完全独立的。Java程序通过流控制来执行程序流，程序中单个顺序的流控制称为线程，多线程则指的是在单个程序中可以同时运行多个不同的线程，执行不同的任务。多线程意味着一个程序的多行语句可以看上去几乎在同一时间内同时运行。线程与

3、 进程相似，是一段完成某个特定功能的代码，是程序中单个顺序的流控制；但与进程不同的是，同类的多个线程是共享一块内存空间和一组系统资源，而线程本身的数据通常只有微处理器的寄存器数据，以及一个供程序执行时使用的堆栈。所以系统在产生一个线程，或者在各个线程之间切换时，负担要比进程小的多，正因如此，线程被称为轻负荷进程（light-weight process）。一个进程中可以包含多个线程。程序（program）是对数据描述与操作的代码的集合，是应用程序执行的脚本进程（process）是程序的一次执行过程，是系统运行程序的基本单位多任务（multitask）是指在一个系统中可以同时运行多个程序，即有多

4、个独立运行的任务，每个任务对应一个进程同进程一样，一个线程也有从创建、运行到消亡的过程，称为线程的生命周期。用线程的状态（state）表明线程处在生命周期的哪个阶段。线程有创建、可运行、运行中、阻塞、死亡 五种状态。通过线程的控制与调度可使线程在这几种状态间转化。每个程序至少自动拥有一个线程，称为主线程。当程序加载到内存时，启动主线程。要加载其他线程，程序就要使用Runnable 接口和 Thread 类从系统方面：一般来说，当运行一个应用程序的时候，就启动了一个进程，当然有些会启动多个进程。启动进程的时候，操作系统会为进程分配资源，其中最主要的资源是内存空间，因为程序是在内存中运行的。在进程

5、中，有些程序流程块是可以乱序执行的，并且这个代码块可以同时名师资料总结-精品资料欢迎下载-名师精心整理-第 1 页，共 17 页 -被多次执行。实际上，这样的代码块就是线程体。线程是进程中乱序执行的代码流程。当多个线程同时运行的时候，这样的执行模式成为并发执行。多线程的目的是为了最大限度的利用CPU 资源。Java 编写程序都运行在在Java 虚拟机（JVM）中，在 JVM 的内部，程序的多任务是通过线程来实现的。每用java命令启动一个java 应用程序，就会启动一个JVM 进程。在同一个 JVM 进程中，有且只有一个进程，就是它自己。在这个JVM 环境中，所有程序代码的运行都是以线程来运行

6、。一般常见的Java 应用程序都是单线程的。比如，用 java 命令运行一个最简单的HelloWorld的 Java 应用程序时，就启动了一个JVM 进程，JVM 找到程序程序的入口点main()，然后运行 main()方法，这样就产生了一个线程，这个线程称之为主线程。当main方法结束后，主线程运行完成。JVM 进程也随即退出。对于一个进程中的多个线程来说，多个线程共享进程的内存块，当有新的线程产生的时候，操作系统不分配新的内存，而是让新线程共享原有的进程块的内存。因此，线程间的通信很容易，速度也很快。不同的进程因为处于不同的内存块，因此进程之间的通信相对困难。实际上，操作的系统的多进程实现

7、了多任务并发执行，程序的多线程实现了进程的并发执行。多任务、多进程、多线程的前提都是要求操作系统提供多任务、多进程、多线程的支持。在 Java 程序中，JVM 负责线程的调度。线程调度是值按照特定的机制为多个线程分配CPU的使用权。调度的模式有两种：分时调度和抢占式调度。分时调度是所有线程轮流获得CPU 使用权，并平均分配每个线程占用CPU 的时间；抢占式调度是根据线程的优先级别来获取CPU 的使用权。JVM 的线程调度模式采用了抢占式模式。所谓的“并发执行”、“同时”其实都不是真正意义上的“同时”。众所周知，CPU 都有个时钟频率，表示每秒中能执行cpu 指令的次数。在每个时钟周期内，CPU

8、 实际上只能去执行一条（也有可能多条）指令。操作系统将进程线程进行管理，轮流（没有固定的顺序）分配每个进程很短的一段是时间（不一定是均分），然后在每个线程内部，程序代码自己处理该进程内部线程的时间分配，多个线程之间相互的切换去执行，这个切换时间也是非常短的。因此多任务、多进程、多线程都是操作系统给人的一种宏观感受，从微观角度看，程序的运行是异步执行的。【JAVA 与多线程，Runnable 接口与 Thread 类】接上文，在 Java 中，多线程的实现有两种方式：扩展 java.lang.Thread类实现 java.lang.Runnable接口综述：两种创建线程方法的比较比较两者的特点和

9、应用领域：直接继承线程Thread 类。该方法编写简单，可以直接操作线程，适用于单重继承情况，因而不能在继承其他类实现 Runnable 接口。当一个线程已继承了另一个类时，就只能用实现Runnable 接口的方法来创建线名师资料总结-精品资料欢迎下载-名师精心整理-第 2 页，共 17 页 -程，且便于保持程序风格的一致性。Runnable 接口Runnable 接口中声明了一个run 方法public void run()Runnable 接口中的run 方法只是一个未实现的方法。一个线程对象必须实现run 方法完成线程的所有活动，已实现的run 方法称为该对象的线程体。任何实现 Runn

10、able 接口的对象都可以作为一个线程的目标对象.Thread 类Thread 类将 Runnable 接口中的 run 方法实现为空方法，并定义许多用于创建和控制线程的方法。格式为：public class Thread extends Object implements Runnable 构造方法：public Thread()public Thread(String name)public Thread(Runnable target)public Thread(Runnable target,String name)public Thread(ThreadGroup group,Run

11、nable target)public Thread(ThreadGroup group,String name)public Thread(ThreadGroup group,Runnable target,String name)Thread 类的静态方法：public static Thread currentThread()/返回当前执行线程的引用对象public static intactiveCount()/返回当前线程组中活动线程个数public static enumerate(Thread tarray)/将当前线程组中的活动线程拷贝到tarray 数组中，包括子线程Thre

12、ad 类的实例方法：public final String getName()/返回线程名public final void setName(String name)/设置线程的名字为name public void start()/启动已创建的线程对象public final boolean isAlive()/返回线程是否启动的状态public final ThreadGroup getThreadGroup()/返回当前线程所属的线程组名public String toString()/返回线程的字符穿信息扫盲已经够了，下面上程序扩展 java.lang.Thread 类TestMiti

13、Thread.java 本例通过继承Thread 类来创建线程的方法。类Thread1 声明为 Thread 的子类，它的构造方法定义线程名和起始参数。/*FileName:TestMitiThread.java Createdby:XXXXXXX.Copyright:*Copyright(c)XXXXXXX*Author:DUSTIN*Modifier:DUSTIN*DateTime:YYYYMMDD*Readme:*通过扩展 Thread 类实现多线程名师资料总结-精品资料欢迎下载-名师精心整理-第 3 页，共 17 页 -*/publicclass TestMitiThread publ

14、icstaticvoid main(String rags)System.out.println(Thread.currentThread().getName()+线程运行开始!);new MitiSay(A).start();new MitiSay(B).start();System.out.println(Thread.currentThread().getName()+线程运行结束!);class MitiSay extends Thread public MitiSay(String threadName)super(threadName);publicvoid run()System

15、.out.println(getName()+线程运行开始!);for (int i=0;i 10;i+)System.out.println(i+getName();try sleep(int)Math.random()*10);catch (InterruptedException e)e.printStackTrace();System.out.println(getName()+线程运行结束!);程序运行结果：main 线程运行开始!main 线程运行结束!A 线程运行开始!0 A 1 A B 线程运行开始!2 A 0 B 3 A 4 A 1 B 5 A 6 A 7 A 名师资料总结-

16、精品资料欢迎下载-名师精心整理-第 4 页，共 17 页 -8 A 9 A A 线程运行结束!2 B 3 B 4 B 5 B 6 B 7 B 8 B 9 B B 线程运行结束!说明程序启动运行main时候，java 虚拟机启动一个进程，主线程 main在 main()调用时候被创建。随着调用 MitiSay的两个对象的start方法，另外两个线程也启动了，这样，整个应用就在多线程下运行。在一个方法中调用Thread.currentThread().getName()方法，可以获取当前线程的名字。在 mian方法中调用该方法，获取的是主线程的名字。注意：start()方法的调用后并不是立即执行多

17、线程代码，而是使得该线程变为可运行态（Runnable），什么时候运行是由操作系统决定的。从程序运行的结果可以发现，多线程程序是乱序执行。因此，只有乱序执行的代码才有必要设计为多线程。Thread.sleep()方法调用目的是不让当前线程独自霸占该进程所获取的CPU 资源，以留出一定时间给其他线程执行的机会。实际上所有的多线程代码执行顺序都是不确定的，每次执行的结果都是随机的。实现 java.lang.Runnable接口TestMitiThread1.java/*FileName:TestMitiThread1.java*Createdby:XXXXXXXXXX*Copyright:Copy

18、right(c)YYYY-YYYY*Company:ICBCSDC*Author:DUSTIN*Modifier:DUSTIN*DateTime:YYYYMMDD*Readme:*通过实现Runnable接口实现多线程*/publicclass TestMitiThread1 implements Runnable publicstaticvoid main(String args)名师资料总结-精品资料欢迎下载-名师精心整理-第 5 页，共 17 页 -System.out.println(Thread.currentThread().getName()+线程运行开始!);TestMitiT

19、hread1 test=new TestMitiThread1();Thread thread1=new Thread(test);Thread thread2=new Thread(test);thread1.start();thread2.start();System.out.println(Thread.currentThread().getName()+线程运行结束!);publicvoid run()System.out.println(Thread.currentThread().getName()+线程运行开始!);for (int i=0;i 10;i+)System.out.

20、println(i+Thread.currentThread().getName();try Thread.sleep(int)Math.random()*10);catch (InterruptedException e)e.printStackTrace();System.out.println(Thread.currentThread().getName()+线程运行结束!);注释：Thread public Thread(Runnable target)分配新的 Thread 对象。这种构造方法与 Thread(null,target,gname)具有相同的作用，其中的gname是一个

21、新生成的名称。自动生成的名称的形式为“Thread-”+n，其中的n为整数。运行结果main 线程运行开始!Thread-0 线程运行开始!main 线程运行结束!0 Thread-0 Thread-1 线程运行开始!0 Thread-1 1 Thread-1 1 Thread-0 2 Thread-0 2 Thread-1 3 Thread-0 3 Thread-1 4 Thread-0 名师资料总结-精品资料欢迎下载-名师精心整理-第 6 页，共 17 页 -4 Thread-1 5 Thread-0 6 Thread-0 5 Thread-1 7 Thread-0 8 Thread-0

22、6 Thread-1 9 Thread-0 7 Thread-1 Thread-0 线程运行结束!8 Thread-1 9 Thread-1 Thread-1 线程运行结束!说明：TestMitiThread1类通过实现Runnable接口，使得该类有了多线程类的特征。run（）方法是多线程程序的一个约定。所有的多线程代码都在run 方法里面。Thread类实际上也是实现了Runnable接口的类。在启动的多线程的时候，需要先通过Thread类的构造方法Thread(Runnable target)构造出对象，然后调用Thread对象的 start()方法来运行多线程代码。实际上所有的多线程代

23、码都是通过运行Thread 的 start()方法来运行的。因此，不管是扩展 Thread 类还是实现Runnable 接口来实现多线程，最终还是通过Thread 的对象的API来控制线程的，熟悉Thread 类的 API 是进行多线程编程的基础。扩展知识（线程组）：线程组每个线程都是一个线程组的成员，线程组把多个线程集成为一个对象，通过线程组可以同时对其中的多个线程进行操作，如启动一个线程组的所有线程等。Java的线程组由java.lang 包中的 Thread Group类实现。ThreadGroup 类用来管理一组线程，包括：线程的数目，线程间的关系，线程正在执行的操作，以及线程将要启动

24、或终止时间等。线程组还可以包含线程组。在Java的应用程序中，最高层的线程组是名位main 的线程组，在main 中还可以加入线程或线程组，在mian 的子线程组中也可以加入线程和线程组，形成线程组和线程之间的树状继承关系【线程的控制与调度】线程的生命周期线程的状态表示线程正在进行的活动以及在此时间段内所能完成的任务。线程有创建、可运行、运行中、阻塞、死亡五中状态。一个具有生命的线程，总是处于这五种状态之一。名师资料总结-精品资料欢迎下载-名师精心整理-第 7 页，共 17 页 -创建状态使用 new 运算符创建一个线程后，该线程仅仅是一个空对象，系统没有分配资源，称该线程处于创建状态（new

25、 thread）可运行状态使用 start()方法启动一个线程后，系统为该线程分配了除CPU 外的所需资源，使该线程处于可运行状态（Runnable）运行中状态Java 运行系统通过调度选中一个Runnable 的线程，使其占有CPU 并转为运行中状态（Running）。此时，系统真正执行线程的run（）方法。阻塞状态一个正在运行的线程因某种原因不能继续运行时，进入阻塞状态（Blocked）死亡状态线程结束后是死亡状态（Dead）（线程执行完了或者因异常退出了run()方法）线程调度与优先级线程的调度模型同一时刻如果有多个线程处于可运行状态，则他们需要排队等待CPU 资源。此时每个线程自动获得

26、一个线程的优先级（priority）,优先级的高低反映线程的重要或紧急程度。可运行状态的线程按优先级排队，线程调度依据优先级基础上的“先到先服务”原则。线程调度管理器负责线程排队和CPU 在线程间的分配，并由线程调度算法进行调度。当线程调度管理器选种某个线程时，该线程获得CPU 资源而进入运行状态。线程调度是先占式调度，即如果在当前线程执行过程中一个更高优先级的线程进入可运行状态，则这个线程立即被调度执行。先占式调度分为：独占式和分时方式。独占方式下，当前执行线程将一直执行下去，直到执行完毕或由于某种原因主动放弃CPU，或 CPU 被一个更高优先级的线程抢占分时方式下，当前运行线程获得一个时间

27、片，时间到时，即使没有执行完也要让出CPU，名师资料总结-精品资料欢迎下载-名师精心整理-第 8 页，共 17 页 -进入可运行状态，等待下一个时间片的调度。系统选中其他可运行状态的线程执行分时方式的系统使每个线程工作若干步，实现多线程同时运行线程的优先级用110 表示，1 表示优先级最高，默认值是 5。每个优先级对应一个Thread类的公用静态常量。如：public static final int NORM_PRIORITY=5 public static final int MIN_PRIORITY=1 public static final int MAX_PRIORITY=10改变线

28、程状态1)线程睡眠 sleep()public static void sleep(long millis)throw InterruptedException 当前线程睡眠（停止执行）若干豪秒，线程由运行中的状态进入不可运行状态，睡眠时间过后进程再进入可运行状态。2)暂停线程yield()public static void yield()yield()暂停当前线程执行，允许其他线程执行。该线程仍处于可运行状态，不转为阻塞状态。此时，系统选择其他同优先级线程执行，若无其他同优先级程，则选中该线程继续执行。3)连接线程 join()join()方法使当前暂停执行，等待调用该方法的线程结束后再继

29、续执行本线程。它有三种调用方法：public final void join()throws InterruptedException public final void join(long mills)throws InterruptedException public final void join(long mills,int nanos)throws InterruptedException 等待调用该方法的线程结束，或者最多等待millis 毫秒+nanos纳秒后，再继续执行本线程。如果需要在一个线程中等待，直到另一个线程消失，可以调用join()方法。如果当前线程另一线程中断，jo

30、in()方法会抛出InterruptedException 异常。4)中断线程interrupt()public void interrupt()public boolean isInterrupted()public static boolean interrupted()interrupt()方法为线程设置一个中断标记,以便于 run()方法运行时使用isInterrupted()方法能够检测到，此时，线程在sleep（）方法抛出一个Interr uptedException 异常，然后捕获这个异常以处理超时。例 Welcome.java：改变线程状态。本例演示线程对象的生命周期从创建到结

31、束的过程，其间使用new()、start()、sleep()、interrupt()等方法改变线程的状态。本例综合运用内部类、图形界面、线程等多方面技术实现设计思想。程序有思想，有内涵，值得学习程序如下：/*FileName:Welcome.java*Createdby:XXXXXXXXXX*Copyright:Copyright(c)YYYY-YYYY*Company:ICBCSDC名师资料总结-精品资料欢迎下载-名师精心整理-第 9 页，共 17 页 -*Author:DUSTIN*Modifier:DUSTIN*DateTime:YYYYMMDD*Readme:*/import java

32、.awt.*;import java.awt.event.*;publicclass Welcome extends WindowAdapter implements ActionListener Frame f;static Welcome.Thread3 wt1,wt2;publicstaticvoid main(String arg)Welcome w=new Welcome();w.display();wt1=w.new Thread3(Welcome!);wt2=w.new Thread3(How are you?);wt2.start();wt2.setButton();/设置按钮

33、状态 publicvoid display()f =new Frame(Welcome);f.setSize(400,240);f.setLocation(200,140);f.setBackground(Color.lightGray);f.setLayout(new GridLayout(4,1);f.addWindowListener(this);f.setVisible(true);publicclass Thread3 extends Thread Panel p1;Label lb1;TextField tf1,tf2;Button b1,b2;intsleeptime=(int)

34、(Math.random()*100);public Thread3(String str)super(str);for (int i=0;i i)value =value -i;/取走时,value 值减少else/帐户金额不够所取时 i=value;value =0;/取走全部所余金额 return i;int howmatch()/查看帐户上现有金额 returnvalue;class Save1 extends Thread /存款线程 private Account1 a1;privateintamount;public Save1(Account1 a1,int amount)th

35、is.a1=a1;this.amount=amount;publicvoid run()int k=a1.howmatch();try名师资料总结-精品资料欢迎下载-名师精心整理-第 13 页，共 17 页 -sleep(1);/花费时间 catch(InterruptedException e)System.out.println(e);a1.put(amount);System.out.println(现有+k+,存入 +amount+,余额 +a1.howmatch();publicstaticvoid main(String args)Account1 a1=new Account1(

36、);(new Save1(a1,100).start();(new Save1(a1,200).start();(new Fetch1(a1,500).start();class Fetch1 extends Thread /取款线程 private Account1 a1;privateintamount;public Fetch1(Account1 a1,int amount)this.a1=a1;this.amount=amount;publicvoid run()int k=a1.howmatch();try sleep(1);/花费时间 catch(InterruptedExcept

37、ion e)System.out.println(e);System.out.println(现有+k+,取走 +a1.get(amount)+,余额 +a1.howmatch();名师资料总结-精品资料欢迎下载-名师精心整理-第 14 页，共 17 页 -程序运行结果：现有 0,存入 100,余额 100 现有 0,存入 200,余额 300 现有 0,取走 300,余额 0 2)Synchronized Synchronized 锁定一段代码，称为创建一个代码临界区，使得线程必须等候特定资源的所有权。当第一个线程执行这段代码时，它获取特定的对象的所有权，即拥有该对象的锁。此时，如果有第二个

38、线程对同一个对象也要执行这段代码时，它试图获取该对象的所有权，但因该对象已被锁定，则第二个线程必须等待，直到锁被释放为止。第一个线程执行完后，自动释放了锁，接下去第二个线程获得锁并可运行。这样就形成了多个线程对同一个对象的“互斥”使用方式，该对象称为“同步对象”。这种锁定方式是针对某个特定对象而言的。如果有两个线程同时对两个不同的对象进行操作，则没有锁定，它们可以同时进入代码的临界区例Save2.java：带锁定的存取款线程设计。class Save2 extends Thread/存款线程 private Account1 a1;privateintamount;public Save2(A

39、ccount1 a1,int amount)this.a1=a1;this.amount=amount;publicvoid run()synchronized(a1)/锁定帐户对象 int k=a1.howmatch();try sleep(1);/花费时间 catch (InterruptedException e)System.out.println(e);a1.put(amount);System.out.println(现有 +k+,存入 +amount+,余额+a1.howmatch();publicstaticvoid main(String args)Account1 a1=n

40、ew Account1();名师资料总结-精品资料欢迎下载-名师精心整理-第 15 页，共 17 页 -(new Save2(a1,100).start();(new Save2(a1,200).start();(new Fetch2(a1,500).start();class Fetch2 extends Thread/取款线程 private Account1 a1;privateintamount;public Fetch2(Account1 a1,int amount)this.a1=a1;this.amount=amount;publicvoid run()synchronized(

41、a1)/锁定帐户对象 int k=a1.howmatch();try sleep(1);/花费时间 catch (InterruptedException e)System.out.println(e);System.out.println(现有 +k+,取走 +a1.get(amount)+,余额+a1.howmatch();程序运行结果：现有 0,存入 100,余额 100 现有 100,存入 200,余额 300 现有 300,取走 300,余额 0 传送数据的线程同步运行1)线程间传送数据如果多个线程同时运行，而且相互间需要传送数据，则必须使线程运行的步调一致，才能保证传送的数据及时准

42、确收到，这称为线程同步问题。2)synchronized 与“互斥锁”标志如果将 Buffer1 类中的 put 和 get 方法声明为“互斥”方法：名师资料总结-精品资料欢迎下载-名师精心整理-第 16 页，共 17 页 -synchronized void put(int)synchronized int get()则意味着任一时刻只能有一个线程访问put 或 get 方法。但可以有两个线程同时分别访问 put 和 get 方法。所以必须增加称为“互斥锁标志”（lock flag）的信号量。这样在任一时刻只有一个线程可以更改共享数据，从而保证数据的完整性和一致性。死锁问题多线程在使用互斥机制实现同步的同时，存在“死锁”的潜在危险。如果多个线程都处于等待状态而无法被唤醒时，就构成死锁（deallock）此时处于等待状态的多个线程占用系统资源，但无法运行，因此不会释放自己的资源，由于系统资源有限程序停止运行。Java技术即不能发现死锁也不能避免死锁。所以程序员编程时应注意死锁问题，尽量避免。避免死锁的有效方法是：线程因为某个条件未满足而受阻，不能让其继续占有资源如果有多个对象需要互斥访问，应确定线程获得锁的顺序，并保证整个程序以相反的顺序释放锁【附件】以下为 JDK 上关于 Thread 的描述，仅供参考名师资料总结-精品资料欢迎下载-名师精心整理-第 17 页，共 17 页 -