多线程【第二十章】

2023-11-29 03:12
文章标签 多线程 第二十章

本文主要是介绍多线程【第二十章】，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

 

线程简介


世间有很多工作都是可以同时完成的。例如，人体可以同时进行呼吸、血液循环、思考问题等活动;用户既可以使用计算机听歌，也可以使用它打印文件。同样，计算机完全可以将多种活动同时进行，这种思想放在 Java 中被称为并发，而将并发完成的每一件事情称为线程。在 Java 中，并发机制非常重要。在以往的程序设计中，我们都是一个任务完成后再进行下一个任务，这样下一个任务的开始必须等待前一个任务的结束。Java 语言提供了并发机制，程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机制被称为多线程。然
而，有必要强调的是，并不是所有编程语言都支持多线程。

创建线程

 继承 Thread 类

Thread 类是java.lang 包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新线程需要建立 Thread实例。Thread 类中常用的两个构造方法如下:

  • public Thread(String threadName): 创建一个名称为threadName 的线程对象
  • public Thread0:创建一个新的线程对象。

继承Thread 类创建一个新的线程的语法如下:

public class ThreadTest extends Thread{
}

完成线程真正功能的代码放在类的 run0方法中，当一个类继承 Thread 类后，就可以在该类中覆盖

run0方法，将实现该线程功能的代码写入 run0方法中，然后调用 Thread 类中的 start0方法执行线程,Thread 对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在也就是调用run0方法。run0方法中。run0方法必须使用以下语法格式:

public void run(){
}

当执行一个线程程序时，就自动产生一个线程，主方法正是在这个线程上运行的。当不再启动其他线程时，该程序就为单线程程序，如本章以前的程序都是单线程程序。主方法线程启动由Java虚拟机负责，程序员负责启动自己的线程。代码如下:

publlc atatic void main(Stringll args) {
now ThreadTest().start();}

例题1

package twentieth;public class ThreadTest extends Thread{public void run() {for(int i=1;i<=10;i++) {System.out.print(i+" ");}}public static void main(String[] args) {ThreadTest th = new ThreadTest();th.start();}}//例题1

实现 Runnable 接口

到目前为止，线程都是通过扩展 Thread 类来创建的，如果程序员需要继承其他类(非 Thread类),而且还要使当前类实现多线程，那么可以通过 Runnable 接口来实现。例如，一个扩展JFrame类的GUI程序不可能再继承 Thread 类，因为 Java 语言中不支持多继承，这时该类就需要实现 Runnable 接口使其具有使用线程的功能。实现 Runnable 接口的语法如下:
 

public class Thread extends Object implements Runnable

 实现 Runnable 接口的程序会创建一个 Thread 对象，并将 Runnable 对象与 Thread 对象相关联。Thread
类中有以下两个构造方法:

  • public Thread(Runnable target)。
  • public Thread(Runnable target,String name)。

这两个构造方法的参数中都存在 Runnable 实例，使用以上构造方法就可以将 Runnable 实例与Thread 实例相关联。
使用Runnable 接口启动新的线程的步骤如下:

  • (1)建立Runnable 对象。
  • (2)使用参数为Runnable 对象的构造方法创建 Thread 实例
  • (3)调用 start0方法启动线程。

通过 Runnable 接口创建线程时，程序员首先需要编写一个实现 Runnable 接口的类，然后实例化该类的对象这样就建立了 Runnable 对象;接下来使用相应的构造方法创建Thread实例;最后使用该实例调用Thread 类中的start0方法启动线程。图202表明了实现Runnable 接口创建线程的流程。

线程最引人注目的部分应该是与 Swing 相结合创建GUT 程序，下面演示一个 GUI 程序，该程序实现了图标滚动的功能。

例题2

package twentieth;import java.awt.Container;import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFrame;
import javax.swing.JLabel;public class SwingAndThread  extends JFrame{int count = 0;public SwingAndThread() {setBounds(300,200,250,100);Container container = getContentPane();container.setLayout(null);Icon icon = new ImageIcon("src\\1.gif");JLabel jl = new JLabel(icon);jl.setBounds(10,10,200,50);Thread t = new Thread() {public void run() {while(true){jl.setBounds(count,10,200,50);try {Thread.sleep(500);}catch(InterruptedException e) {e.printStackTrace();}count += 4;if(count>=200) {count = 10;}}}};t.start(); // 启动线程container.add(jl); // 将标签添加到容器中setVisible(true); // 使窗体可见// 设置窗体的关闭方式setDefaultCloseOperation(EXIT_ON_CLOSE);}public static void main(String[] args) {// TODO Auto-generated method stubnew SwingAndThread();}}

 

线程的生命周期


线程具有生命周期，其中包含 7 种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是线程被创建时处于的状态，在用户使用该线程实例调用start0方法之前线程都处于出生状态; 当用户调用 start0方法后，线程处于就绪状态(又被称为可执行
状态):当线程得到系统资源后就进入运行状态。~旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阴塞或死亡状态。当处于运行状态下的线程调用 Thread 类中的 wait0方法时，该线程便进入等待状态，进入等待状态的线程必须调用 Thread 类中的 notify0方法才能被唤醒，而调用 notifyAll0方法可将所有处干等待状态下的线程唤醒;当线程调用 Thread 类中的 sleep0方法时，则会进入休眠状态。如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时线程进入就绕状态，对于阳塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。当线程的 run0方法执行完毕时，线程进入死亡状态

 操作线程的方法


操作线程有很多方法，这些方法可以使线程从某一种状态过渡到另一种状态。

线程的休眠


一种能控制线程行为的方法是调用 sleep0方法,sleep0方法需要一个参数用于指定该线程休眠的时间，该时间以毫秒为单位。在前面的实例中，已经演示过 sleep0方法，它通常是在 run0方法内的循环中被使用。sleep0方法的语法如下:

try(
Thread.sleep(2000);
)catch(InterruptedException e)
e.printStackTrace();


上述代码会使线程在 2 秒之内不会进入就绪状态。由于 sleep0方法的执行有可能抛出
InterruptedException 异常，所以将 sleep0方法的调用放在 try-catch 块中。虽然使用了 sleep0方法的线程在一段时间内会醒来，但是并不能保证它醒来后进入运行状态，只能保证它进入就绪状态。为了使读者更深入地了解线程的休眠方法，来看下面的实例。

例题3

package twentieth;import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;import javax.swing.JFrame;public class SleepMethodTest  extends JFrame{private static Color[] color = { Color.BLACK, Color.BLUE, Color.CYAN, Color.GREEN, Color.ORANGE, Color.YELLOW,Color.RED, Color.PINK, Color.LIGHT_GRAY }; // 定义颜色数组private static final Random rand = new Random(); // 创建随机对象private static Color getC() { // 获取随机颜色值的方法return color[rand.nextInt(color.length)];}public SleepMethodTest() {Thread t = new Thread(new Runnable() { // 创建匿名线程对象int x = 30; // 定义初始坐标int y = 50;public void run() { while (true) { // 无限循环try {Thread.sleep(100); // 线程休眠0.1秒} catch (InterruptedException e) {e.printStackTrace();}Graphics graphics = getGraphics(); // 获取组件绘图上下文对象graphics.setColor(getC()); // 设置绘图颜色graphics.drawLine(x, y, 100, y++); // 绘制直线并递增垂直坐标if (y >= 80) {y = 50;}}}});t.start(); // 启动线程}public static void main(String[] args) {// TODO Auto-generated method stubinit(new SleepMethodTest(), 100, 100);}public static void init(JFrame frame, int width, int height) { // 初始化程序界面的方法frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.setSize(width, height);frame.setVisible(true);}}

线程的加入


如果当前某程序为多线程程序，假如存在一个线程 A，现在需要插入线程 B，并要求线程 B 先行完，然后再续执行线程A，此时可以使用 Thread 类中的jin0方法来完成。这就好比此时读者在看电视，突然有人上门收水费，读者必须付完水费后才能继续看电视。当某个线程使用 join0方法加入另外一个线程时，另一个线程会等待该线程执行完毕后再继续行。下面来看一个使用join0方法的实例。

例题4

package twentieth;
import java.awt.BorderLayout;
import javax.swing.*;public class JoinTest extends JFrame {private Thread threadA; // 定义两个线程private Thread threadB;private JProgressBar progressBar = new JProgressBar(); // 定义两个进度条组件private JProgressBar progressBar2 = new JProgressBar();public static void main(String[] args) {JoinTest test = new JoinTest();test.setVisible(true);}public JoinTest() {setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);setBounds(200, 200, 200, 100);getContentPane().add(progressBar, BorderLayout.NORTH); // 将进度条设置在窗体最北面getContentPane().add(progressBar2, BorderLayout.SOUTH); // 将进度条设置在窗体最南面progressBar.setStringPainted(true); // 设置进度条显示数字字符progressBar2.setStringPainted(true);// 使用匿名内部类形式初始化Thread实例threadA = new Thread(new Runnable() {int count = 0;public void run() { // 重写run()方法while (true) {progressBar.setValue(++count); // 设置进度条的当前值try {Thread.sleep(100); // 使线程A休眠100毫秒threadB.join(); // 使线程B调用join()方法} catch (InterruptedException e) {e.printStackTrace();}}}});threadA.start(); // 启动线程AthreadB = new Thread(new Runnable() {int count = 0;public void run() {while (true) {progressBar2.setValue(++count); // 设置进度条的当前值try {Thread.sleep(100); // 使线程B休眠100毫秒} catch (InterruptedException e) {e.printStackTrace();}if (count == 100) // 当count变量增长为100时break; // 跳出循环}}});threadB.start(); // 启动线程B}
}

 线程的中断


以往有的时候会使用 stop0方法停止线程，但当前版本的 JDK 早已废除了 stop0方法，不建议使用stop0方法来停止一个线程的运行。现在提倡在 run0方法中使用无限循环的形式，然后使用一个布尔型
标记控制循环的停止。如果线程是因为使用了 sleep0或 wait0方法进入了就绪状态，可以使用 Thread 类中 interrupt0方法使线程离开run0方法，同时结束线程，但程序会抛出 InterruptedException 异常，用户可以在处理该异常时完成线程的中断业务处理，如终止 while 循环。
下面的实例演示了某个线程使用 interrupted0方法，同时程序抛出了 InterruptedException 异常，在异常处理时结束了 while 循环。在项目中，经常在这里执行关闭数据库连接和关闭 Socket 连接等操作

例题5

package twentieth;import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JProgressBar;public class InterruptedSwing extends JFrame {public static void main(String[] args) {init(new InterruptedSwing(), 100, 100);}public InterruptedSwing() {JProgressBar progressBar = new JProgressBar(); // 创建进度条getContentPane().add(progressBar, BorderLayout.NORTH); // 将进度条放置在窗体合适位置JButton button = new JButton("停止");getContentPane().add(button, BorderLayout.SOUTH);progressBar.setStringPainted(true); // 设置进度条上显示数字Thread t = new Thread(new Runnable() {int count = 0;public void run() {while (true) {progressBar.setValue(++count); // 设置进度条的当前值try {Thread.sleep(100); // 使线程休眠100毫秒} catch (InterruptedException e) { // 捕捉InterruptedException异常System.out.println("当前线程序被中断");break;}}}});button.addActionListener(new ActionListener() {@Overridepublic void actionPerformed(ActionEvent e) {t.interrupt(); // 中断线程}});t.start(); // 启动线程}public static void init(JFrame frame, int width, int height) {frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.setSize(width, height);frame.setVisible(true);}
}

线程的礼让

Thread 类中提供了一种礼让方法，使用 ield0方法表示，它只是给当前正处于运行状态的线程一个提醒，告知它可以将资源礼让给其他线程，但这仅是一种暗示，没有任何一种机制保证当前线程会将资源礼让

 线程的优先级


每个线程都具有各自的优先级，线程的优先级可以表明在程序中该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。但这并不意味着低优先级的线程得不到运行，而只是它运行的概率比较小，如垃圾回收线程的优先级就较低。
Thread 类中包含的成员变量代表了线程的某些优先级，如 Thread.MIN_PRIORITY (常数 1)ThreadMAX PRIORITY(常数 10)、ThreadNORM PRIORITY(常数 5)。其中，每个线程的优先级都在 ThreadMIN PRIORITY~ThreadMAX PRIORITY，在默认情况下其优先级都是 Thread.NORMPRIORITY。每个新产生的线程都继承了父线程的优先级。
在多任务操作系统中，每个线程都会得到一小段 CPU 时间片运行，在时间结束时，将轮换另一个线程进入运行状态，这时系统会选择与当前线程优先级相同的线程予以运行。系统始终选择就绪状态下优先级较高的线程进入运行状态。处于各个优先级状态

例题6

package twentieth;public class PriorityTest implements Runnable {String name;public PriorityTest(String name) {this.name = name;}@Overridepublic void run() {String tmp = "";for (int i = 0; i < 50000; i++) {// 完成五万次字符串拼接tmp += i;}System.out.println(name + "线程完成任务");}public static void main(String[] args) {Thread a = new Thread(new PriorityTest("A"));a.setPriority(1);// A线程优先级最小Thread b = new Thread(new PriorityTest("B"));b.setPriority(3);Thread c = new Thread(new PriorityTest("C"));c.setPriority(7);Thread d = new Thread(new PriorityTest("D"));d.setPriority(10);// D线程优先级最大a.start();b.start();c.start();d.start();}
}

要当另一个线程完成时，才会继续刚开始时间不够的线程

线程同步

在单线程程序中，每次只能做一件事情，后面的事情需要等待前面的事情完成后才可以进行，但是如果使用多线程程序，就会发生两个线程抢占资源的问题，如两个人同时说话、两个人同时过同-个独木桥等。所以，在多线程编程中需要防止这些资源访问的冲突。Java 提供了线程同步的机制来止资源访问的冲突

线程安全


实际开发中，使用多线程程序的情况很多，如银行排号系统、火车站售票系统等。这种多线程的程序通常会发生问题，以火车站售票系统为例，在代码中判断当前票数是否大于 0，如果大于0则执行将该票出售给乘客的功能，但当两个线程同时访问这段代码时(假如这时只剩下一张票)，第一个线程将票售出，与此同时第二个线程也已经执行完成判断是否有票的操作，并得出票数大于 0 的结论，于是它也执行售出操作，这样就会产生负数。所以，在编写多线程程序时，应该考虑到线程安全问题。实质上线程安全问题来源于两个线程同时存取单一对象的数据。

线程同步机制


那么，该如何解决资源共享的问题呢? 所有解决多线程资源冲突问题的方法基本上都是采用给定时间只允许一个线程访问共享资源的方法，这时就需要给共享资源上一道锁。这就好比一个人上洗手间时，他进入洗手间后会将门锁上，出来时再将锁打开，然后其他人才可以进入。
1，同步块
Java 中提供了同步机制，可以有效地防止资源冲突。同步机制使用 synchronized 关键字，使用该关键字包含的代码块称为同步块，也称为临界区，语法如下:

synchronized (Object) {
}


通常将共享资源的操作放置在 synhronized 定义的区域内，这样当其他线程获取到这个锁时，就必须等待锁被释放后才可以进入该区域。Object 为任意一个对象，每个对象都存在一个标志位，并具有两个值，分别为 0和 1。一个线程运行到同步块时首先检查该对象的标志位，如果为0状态，表明此同步块内存在其他线程，这时当期线程处于就绪状态，直到处于同步块中的线程执行完同步块中的代码后，这时该对象的标识位设置为 1，当期线程才能开始执行同步块中的代码，并将 Object 对象的标识位设置为 0，以防止其他线程执行同步块中的代码。

例题7

package twentieth;public class SynchronizedTest implements Runnable {int num = 10; // 设置当前总票数public void run() {while (true) { // 设置无限循环synchronized (this) { // 设置同步代码块if (num > 0) { // 判断当前票数是否大于0try {Thread.sleep(100); // 使当前线程休眠100毫秒} catch (InterruptedException e) {e.printStackTrace();}// 票数减1System.out.println(Thread.currentThread().getName() + "——票数" + num--);}}}}public static void main(String[] args) {// 实例化类对象SynchronizedTest t = new SynchronizedTest();// 以该类对象分别实例化4个线程Thread tA = new Thread(t, "线程一");Thread tB = new Thread(t, "线程二");Thread tC = new Thread(t, "线程三");Thread tD = new Thread(t, "线程四");tA.start(); // 分别启动线程tB.start();tC.start();tD.start();}
}

同步方法


同步方法就是在方法前面用 synchronized 关键字修饰的方法，其语法如下:

synchronized void f(){
}


当某个对象调用了同步方法时，该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为 synchronized，否则就会出错修改例 20.7 的代码，将共享资源操作放置在一个同步方法中，代码如下:

int num = 10:
public synchronized void doit() {           //定义同步方法 
if(num>0){
try{
Thread.sleep(10);
}catch(InterruptedException eXe.printStackTrace();
票数"+num-);}
System.out.println(Thread.currentThread().getName()+"一
//在 run()方法中调用该同步方法
public void run()while(true)
doit();
}
}

这篇关于多线程【第二十章】的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/431233。

相关文章

多线程解析报表

多线程解析报表

假如有这样一个需求，当我们需要解析一个Excel里多个sheet的数据时，可以考虑使用多线程，每个线程解析一个sheet里的数据，等到所有的sheet都解析完之后，程序需要提示解析完成。 Way1 join import java.time.LocalTime;public class Main {public static void main(String[] args) thro
阅读更多...
Java 多线程概述

Java 多线程概述

多线程技术概述   1.线程与进程 进程：内存中运行的应用程序，每个进程都拥有一个独立的内存空间。线程：是进程中的一个执行路径，共享一个内存空间，线程之间可以自由切换、并发执行，一个进程最少有一个线程，线程实际数是在进程基础之上的进一步划分，一个进程启动之后，进程之中的若干执行路径又可以划分成若干个线程 2.线程的调度 分时调度：所有线程轮流使用CPU的使用权，平均分配时间抢占式调度
阅读更多...
Java 多线程的基本方式

Java 多线程的基本方式

Java 多线程的基本方式 基础实现两种方式： 通过实现Callable 接口方式（可得到返回值)：
阅读更多...
JAVA- 多线程

JAVA- 多线程

一，多线程的概念 1.并行与并发 并行：多个任务在同一时刻在cpu 上同时执行并发：多个任务在同一时刻在cpu 上交替执行 2.进程与线程 进程：就是操作系统中正在运行的一个应用程序。所以进程也就是“正在进行的程序”。（Windows系统中,我们可以在任务管理器中看 到进程） 线程：是程序运行的基本执行单元。当操作系统执行一个程序时， 会在系统中建立一个进程，该进程必须至少建立一个线
阅读更多...
多线程篇（阻塞队列- LinkedBlockingDeque）（持续更新迭代）

多线程篇（阻塞队列- LinkedBlockingDeque）（持续更新迭代）

目录 一、LinkedBlockingDeque是什么 二、核心属性详解 三、核心方法详解 addFirst(E e) offerFirst(E e) putFirst(E e) removeFirst() pollFirst() takeFirst() 其他 四、总结 一、LinkedBlockingDeque是什么 首先queue是一种数据结构，一个集合中
阅读更多...
多线程篇（阻塞队列- LinkedBlockingQueue）（持续更新迭代）

多线程篇（阻塞队列- LinkedBlockingQueue）（持续更新迭代）

目录 一、基本概要 1. 构造函数 2. 内部成员 二、非阻塞式添加元素：add、offer方法原理 offer的实现 enqueue入队操作 signalNotEmpty唤醒 删除线程（如消费者线程） 为什么要判断if (c == 0)时才去唤醒消费线程呢？ 三、阻塞式添加元素：put 方法原理 图解：put线程的阻塞过程 四、非阻塞式移除：poll方法原理 dequ
阅读更多...
spring笔记 多线程的支持

spring笔记 多线程的支持

spring的工作机制 136  属性编辑器 140 spring事件的体系结构 168 Bean间的关系 109 继承 依赖 引用     Bean的继承          1 为了简化初始化的属性注入;          2 子Bean和父Bean相同的属性值，使用子Bean的     Bean的依赖 Srping控制相互依赖的Bean之间，属性注入的顺序，防止出错  depend-on
阅读更多...
【编程底层思考】详解Java的JUC多线程并发编程底层组件AQS的作用及原理

【编程底层思考】详解Java的JUC多线程并发编程底层组件AQS的作用及原理

Java中的AbstractQueuedSynchronizer（简称AQS）是位于java.util.concurrent.locks包中的一个核心组件，用于构建锁和其他同步器。AQS为实现依赖于FIFO（先进先出）等待队列的阻塞锁和相关同步器提供了一套高效、可扩展的框架。 一、AQS的作用 统一同步状态管理：AQS提供了一个int类型的成员变量state，用于表示同步状态。子类可以根据自己
阅读更多...
多线程的系列文章

多线程的系列文章

Java多线程学习（一）Java多线程入门 Java多线程学习（二）synchronized关键字（1）   Java多线程学习（二）synchronized关键字（2） Java多线程学习（三）volatile关键字 Java多线程学习（四）等待/通知（wait/notify）机制 Java多线程学习（五）线程间通信知识点补充 Java多线程学习（六）Lock锁的使用 Java多
阅读更多...
多线程 线程池的创建

多线程 线程池的创建

一简介 线程的使用在java中占有极其重要的地位，在jdk1.4极其之前的jdk版本中，关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。Jdk1.5之后加入了java.util.concurrent包，这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。 二：线程池 线程池的作用： 线程池作用就是限制系统中执行线程的数量。
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2