多线程【第二十章】

阿菜好困

已于 2023-11-29 08:54:15 修改

阅读量952

点赞数 20

文章标签： java 算法 jvm

于 2023-11-28 17:28:28 首次发布

本文链接：https://blog.csdn.net/qq_74860378/article/details/134671329

版权

线程简介

世间有很多工作都是可以同时完成的。例如，人体可以同时进行呼吸、血液循环、思考问题等活动;用户既可以使用计算机听歌，也可以使用它打印文件。同样，计算机完全可以将多种活动同时进行，这种思想放在 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 stub
		new 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 stub
		init(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(); // 启动线程A
		threadB = 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() {

			@Override
			public 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;
	}

	@Override
	public 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 的结论，于是它也执行售出操作，这样就会产生负数。所以，在编写多线程程序时，应该考虑到线程安全问题。实质上线程安全问题来源于两个线程同时存取单一对象的数据。

这是小型买票程序没有改动前

package twentieth;

public class ThreadSafeText implements Runnable {
	int num = 10;
	public void run() {
		while (true) {
			if(num>0) {
				try {
					Thread.sleep(100);
				}catch (InterruptedException e) {
					e.printStackTrace();
					
				}
				System.out.println(Thread.currentThread().getName()+"---票数" +num--);
			}
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ThreadSafeText t = new ThreadSafeText();
		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();
	}

}

添加同步锁后的买票小程序

package twentieth;

public class ThreadSafeText implements Runnable {
	int num = 10;
	public void run() {
		while (true) {
			synchronized(this) {//同步锁，要么同时发生，要么都不发生
				if(num>0) {
					try {
						Thread.sleep(100);
					}catch (InterruptedException e) {
						e.printStackTrace();
						
					}
					System.out.println(Thread.currentThread().getName()+"---票数" +num--);
				}
			}
		
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ThreadSafeText t = new ThreadSafeText();
		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();
	}

}

线程同步机制

那么，该如何解决资源共享的问题呢? 所有解决多线程资源冲突问题的方法基本上都是采用给定时间只允许一个线程访问共享资源的方法，这时就需要给共享资源上一道锁。这就好比一个人上洗手间时，他进入洗手间后会将门锁上，出来时再将锁打开，然后其他人才可以进入。
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) { // 判断当前票数是否大于0
                    try {
                        Thread.sleep(100); // 使当前线程休眠100毫秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    // 票数减1
                    System.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();
}
}