• 第二十章 多线程

    20.1 线程简介

    在 Java 中，并发机制非常重要。在以往的程序设计中，我们都是一个任务完成后再进行下一个任务，这样下一个任务的开始必须等待前一个任务的结束。Java 语言提供了并发机制，程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机制被称为多线程。然而，有必要强调的是，并不是所有编程语言都支持多线程。

    20.2 创建线程

    在 Java 中，主要提供两种方式实现线程，分别为继承 java.lang.Thread 类与实现 java.lang.Runnable接口。

    继承Thread类

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

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

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

    public class ThreadTest extends Thread{

    }

    Thread 对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在

    run()方法中。run()方法必须使用以下语法格式:

    public void run(){

    }

    主方法线程自动由 Java虚拟机负责，程序员负责启动自己的线程。代码如下:

    public static void main(Stringl args) {

    new ThreadTest().start()；

    }

     代码案例：

    1. package 二十章;
    2.  
    3. public class ThreadTest extends Thread{
    4. 	public void run() {
    5. 		for(int i = 1;i<=10;i++) {
    6. 			System.out.print(i+" ");
    7. 		 }
    8. 	}
    9. 	public static void main(String[] args) {
    10. 		ThreadTest t =new ThreadTest();
    11. 		t.start();
    12. 	}
    13.  
    14. }

    运行结果：

    实现Runnable接口

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

    public class Thread extends Object implements Runnable

    Threa类中有以下两个构造方法:

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

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

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

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

     代码案例：

    1. package 二十章;
    2.  
    3. import java.awt.Container;
    4.  
    5. import javax.swing.Icon;
    6. import javax.swing.ImageIcon;
    7. import javax.swing.JFrame;
    8. import javax.swing.JLabel;
    9.  
    10. public class SwingAndThread extends JFrame{
    11. 	int count = 0;	//图标横坐标
    12. 	
    13. 	public SwingAndThread() {		
    14. 		setBounds(400,400,500,500);	//绝对定位窗体大小与位置
    15. 		Container container = getContentPane();		//主容器
    16. 		container.setLayout(null);		//使窗体不使用任何布局管理器
    17. 		
    18. 		
    19. 		Icon icon = new ImageIcon("src/二十章/3.gif");	//图标对象
    20. 		JLabel jL = new JLabel(icon);	//显示图标的标签
    21. 		jL.setBounds(100, 100, 200, 500);	//设置标签的位置与大小
    22. 		Thread t = new Thread() {	//定义匿名线程对象
    23. 			public void run() {
    24. 				while (true) {
    25. 					jL.setBounds(count, 100, 500, 200);	//将标签的横坐标用变量表示
    26. 					try {
    27. 						Thread.sleep(500);	//使线程休眠500毫秒
    28. 					}catch(InterruptedException e) {
    29. 						e.printStackTrace();
    30. 					}
    31. 					count += 9;	//使横坐标每次增加9
    32. 					if(count >=200){
    33. 						count = 10;	//当坐标到达标签的最右边时，使其回到标签最左边
    34. 					}
    35. 				}
    36. 			}
    37. 		};
    38. 		t.start();	//启动线程
    39. 		container.add(jL);	//将标签添加到容器中
    40. 		setVisible(true);	//使窗体可见
    41. 		setDefaultCloseOperation(EXIT_ON_CLOSE);	//设置窗体的关闭方式
    42. 	}
    43. 	public static void main(String[] args) {
    44. 		new SwingAndThread();
    45. 	}
    46.  
    47. }

    运行结果：

     

    20.3 线程的生命周期

     一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待，休眠，赌塞或死亡状态。

    要使线程处于就绪，有以下几种方法：

    • 调用 sleep() 方法。
    • 调用 wait() 方法。
    • 等待输入/输出完成。

    当线程处于就绪状态后，可以用以下几种方法使线程再次进入运行状态：

    • 线程调用 notify() 方法。
    • 线程调用 notifyAll() 方法。
    • 线程调用 interrupt() 方法。
    • 线程的休眠时间结束。
    • 输入/输出结束。

    20.4 操作线程的方法

    线程的休眠

    一种能控制线程行为的方法是调用 sleep() 方法需要一个参数用于指定该线程休眠的时间，该时间以毫秒为单位。

    例：每0.1秒绘制一条随机颜色的线条

    1. package 二十章;
    2. import java.awt.Color;
    3. import java.awt.Graphics;
    4. import java.util.Random;
    5.  
    6. import javax.swing.JFrame;
    7.  
    8. public class SleepMethodTest extends JFrame{
    9. 	private static Color[] color= {Color.BLACK,Color.BLUE,Color.CYAN,Color.GREEN,
    10. 		Color.RED,Color.ORANGE,Color.YELLOW,Color.PINK,Color.LIGHT_GRAY};//定义颜色数组
    11. 	private static final Random rand=new Random();//创建随机对象
    12. 	
    13. 	private static Color getC() {//获取随机颜色值的方法
    14. 		return color[rand.nextInt(color.length)];
    15. 	}
    16. 	
    17. 	public  SleepMethodTest(){
    18. 		Thread t=new Thread(new Runnable() {//创建匿名线程对象
    19. 			int x=30;//定义初始坐标
    20. 			int y=50;
    21. 			
    22. 			public void run() {
    23. 				while(true) {//无限循环
    24. 					try {
    25. 						Thread.sleep(100);//线程休眠0.1秒
    26. 					}catch(InterruptedException e) {
    27. 						e.printStackTrace();
    28. 					}
    29. 					Graphics graphics=getGraphics();//获取组件绘图上下文对象
    30. 					graphics.setColor(getC());//设置绘图颜色
    31. 					graphics.drawLine(x, y,150, y++);//绘制直线并递增垂直坐标
    32. 					if(y>=180) {
    33. 						y=50;
    34. 					}
    35. 				}
    36. 			}
    37. 		});
    38. 		t.start();//启动线程
    39. 	}
    40.  
    41. 	public static void main(String[] args) {
    42. 		init(new SleepMethodTest(),200,200);
    43.  
    44. 	}
    45.  
    46. 	public static void init(JFrame frame,int width,int height) {//初始化程序界面的方法
    47. 		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    48. 		frame.setSize(width, height);
    49. 		frame.setVisible(true);
    50. 	}
    51. }

    运行结果：

    线程的加入

    当某个线程使用 join() 方法的加入一个线程时，另外一个线程会等待该线程执行完毕后再继续执行。

     代码案例： 

    1. package 二十章;
    2.  
    3. import java.awt.BorderLayout;
    4.  
    5. import javax.swing.JFrame;
    6. import javax.swing.JProgressBar;
    7.  
    8. public class JoinTest extends JFrame{
    9. 	private Thread threadA;		//定义两个线程
    10. 	private Thread threadB;		
    11. 	private JProgressBar progressBar = new JProgressBar();	//定义两个进度条组件
    12. 	private JProgressBar progressBar2 = new JProgressBar();
    13. 	
    14. 	
    15. 	public static void main(String[] args) {
    16. 		JoinTest test= new JoinTest();
    17. 		test.setVisible(true);
    18.  
    19. 	}
    20. 	
    21. 	public JoinTest() {
    22. 		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    23. 		setBounds(200,200,200,100);
    24. 		getContentPane().add(progressBar,BorderLayout.NORTH);	//将进度条设置在窗体最北面
    25. 		getContentPane().add(progressBar2,BorderLayout.SOUTH);	//将进度条设置在窗体最南面
    26. 		progressBar.setStringPainted(true);		//设置进度条显示数字字符
    27. 		progressBar2.setStringPainted(true);
    28. 		threadA = new Thread(new Runnable() {	//使用匿名内部类形式初始化Thread实例
    29. 			int count = 0;
    30. 			public void run() {		//重写run()方法
    31. 				while(true) {
    32. 					progressBar.setValue(++count);	//设置进度条的当前值
    33. 					try {
    34. 						Thread.sleep(100);	//使线程A休眠100毫秒
    35. 						threadB.join();	//使线程B调用join()方法
    36. 					}catch(InterruptedException e) {
    37. 						e.printStackTrace();
    38. 				}
    39. 			}
    40. 		}
    41. 	});
    42. 		threadA.start();	//启动线程A
    43. 		threadB = new Thread(new Runnable() {
    44. 			int count = 0;
    45. 			public void run() {
    46. 				while(true) {
    47. 					progressBar2.setValue(++count);	//设置进度条的当前值
    48. 					try {
    49. 						Thread.sleep(100);	//使线程B休眠100毫秒
    50. 			
    51. 					}catch(InterruptedException e) {
    52. 						e.printStackTrace();
    53. 				}
    54. 					if(count == 100);	//当count变量增长为100时
    55. 					break;	//跳出循环
    56. 			}
    57. 		}
    58. 	});
    59. 		threadB.start();	//启动线程B
    60.  
    61. 	}
    62. }

    运行结果：

    线程的中断

    以往有时候会使用 stop() 方法停止线程，但当前版本的 JDK 早已废除了 stop() 方法，不建议使用 stop() 方法来停止一个线程的运行。现在提倡在 run() 方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。

     如果线程是因为使用了 sleep()或 wait()方法进入了就入就绪状态，可以使用 Thread()方法，同时程序破除了 InterruptedException 异常，在异常处理时结束了 while 循环。在项目中，经常在这里执行关闭数据连接和关闭 Socket 连接等操作。

     代码案例： 

    1. package 二十章;
    2.  
    3. import java.awt.BorderLayout;
    4. import java.awt.event.ActionEvent;
    5. import java.awt.event.ActionListener;
    6.  
    7. import javax.swing.JButton;
    8. import javax.swing.JFrame;
    9. import javax.swing.JProgressBar;
    10.  
    11. public class InterruptedSwing extends JFrame{
    12. 	
    13. 	public InterruptedSwing() {
    14. 		JProgressBar progressBar = new JProgressBar();	//创建进度条
    15. 		getContentPane().add(progressBar,BorderLayout.NORTH);	//将进度条设置在窗体合适位置
    16. 		JButton button = new JButton("停止");
    17. 		getContentPane().add(button,BorderLayout.SOUTH);
    18. 		progressBar.setStringPainted(true);	//设置进度条上显示数字
    19. 		Thread t= new Thread(new Runnable() {	
    20. 			int count = 0;
    21. 			public void run() {		
    22. 				while(true) {
    23. 					progressBar.setValue(++count);	//设置进度条的当前值
    24. 					try {
    25. 						Thread.sleep(100);	//使线程休眠100毫秒
    26. 					}catch(InterruptedException e) {	//捕捉InterruptedException异常
    27. 						System.out.println("当前线程序被中断");
    28. 						break;
    29. 				}
    30. 			}
    31. 		}
    32. 	});
    33. 		
    34. 		button.addActionListener(new ActionListener() {
    35. 			
    36. 			@Override
    37. 			public void actionPerformed(ActionEvent e) {
    38. 				t.interrupt();	//中断线程
    39. 				
    40. 			}
    41. 		});
    42. 		t.start();	//启动线程
    43. 	}
    44. 	
    45. 	public static void init(JFrame frame,int width,int height) {
    46. 		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    47. 		frame.setSize(width, height);
    48. 		frame.setVisible(true);
    49. 	}
    50.  
    51. 	public static void main(String[] args) {
    52. 		init(new InterruptedSwing(),100,100);
    53. 	}
    54.  
    55. }

    运行结果：

    线程的礼让

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

            yied()方法使具有同样优先级的线程有进入可执行状态的机会，在当前线程放弃执行权时再度回到就绪状态。对于支持多任务的操作系统来说，不需要调用 yied()方法，因为操作系统会为线程自动分配 CPU 时间来执行。

    20.5 线程的优先级

    每个线程都具有各自的优先级，线程的优先级可以表明在程序中该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。但这并不意味着低优先级的线程得不到运行，而只是它运行的概率比较小，如垃圾回收线程的优先级就按照较低。

            线程的优先级可以使用 setPriority()方法调整，如果使用该方法设置的优先级不在 1~10，将产生IllegalArgumentException 异常。

     代码案例： 

    1. package 二十章;
    2.  
    3. public class PriorityTest implements Runnable{
    4. 	String name;
    5. 	
    6. 	public PriorityTest(String name) {
    7. 		this.name = name;
    8. 	}
    9. 	
    10. 	@Override
    11. 	public void run() {
    12. 		String tmp = "";
    13. 		for(int i = 0;i < 50000; i++) {	//完成5万次字符串拼接
    14. 			tmp += i;
    15. 		}
    16. 		System.out.println(name + "线程完成任务");
    17. 		
    18. 	}
    19.  
    20.  
    21. 	public static void main(String[] args) {
    22. 		Thread a = new Thread(new PriorityTest("A"));
    23. 		a.setPriority(1);		//A线程优先级最小
    24. 		Thread b = new Thread(new PriorityTest("B"));
    25. 		b.setPriority(3);
    26. 		Thread c = new Thread(new PriorityTest("C"));
    27. 		c.setPriority(7);
    28. 		Thread d = new Thread(new PriorityTest("D"));
    29. 		d.setPriority(10);	//D线程优先级最大
    30. 		a.start();
    31. 		b.start();
    32. 		c.start();
    33. 		d.start();
    34. 	}
    35. }

    运行结果：

    20.6 线程同步

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

    线程安全

      在编写多线程时时，因该考虑到线程安全问题。实质上线程问题来源两个线程同时存取单一对象的数据。

     代码案例： 

    1. package 二十章;
    2.  
    3. public class ThreadSafeTest implements Runnable{
    4. 	int num = 10;	//设置当前票数
    5. 	
    6. 	
    7. 	@Override
    8. 	public void run() {
    9. 		while(true) {	//设置无限循环
    10. 			if(num >0) {	//设置当前票数是否大于0
    11. 				try {
    12. 					Thread.sleep(100);	//使当前线程休眠100毫秒
    13. 				}catch(InterruptedException e) {
    14. 						e.printStackTrace();
    15. 				}
    16. 				System.out.println(Thread.currentThread().getName()+"------票数"+num--);	//票数减一
    17. 			}
    18. 		}
    19. 	}
    20.  
    21. 	public static void main(String[] args) {
    22. 		ThreadSafeTest t = new ThreadSafeTest();	//实例化类对象
    23. 		Thread tA = new Thread(t,"线程一");	//以该类对象分别实例化4个线程
    24. 		Thread tB = new Thread(t,"线程二");
    25. 		Thread tC = new Thread(t,"线程三");
    26. 		Thread tD = new Thread(t,"线程四");
    27. 		tA.start();	//分别启动线程
    28. 		tB.start();
    29. 		tC.start();
    30. 		tD.start();
    31. 	}
    32. }

    运行结果：

    线程同步机制

     所以解决多线程资源问题的方法基本上都是采用给定时间只允许一个线程访问共享资源的方法。这时就需要给共享源上一道锁。

    1、同步块

     Java中提供了同步机制，可以有效地防止资源冲突。同步机制使用 synchronized 关键字，使用该关键字包含的代码块称为同步块，也称临界区，语法如下：

    synchronized(Object){

    }

     代码案例： 

    1. package 二十章;
    2.  
    3. public class ThreadSafeTest implements Runnable{
    4. 	int num = 10;	//设置当前票数
    5. 	
    6. 	
    7. 	@Override
    8. 	public void run() {
    9. 		while(true) {	//设置无限循环
    10. 			synchronized(this) {	//同步锁
    11. 			if(num >0) {	//设置当前票数是否大于0
    12. 				try {
    13. 					Thread.sleep(100);	//使当前线程休眠100毫秒
    14. 				}catch(InterruptedException e) {
    15. 						e.printStackTrace();
    16. 				}
    17. 				System.out.println(Thread.currentThread().getName()+"------票数"+num--);	//票数减一
    18. 			}
    19. 		}
    20. 	}
    21. }
    22. 	public static void main(String[] args) {
    23. 		ThreadSafeTest t = new ThreadSafeTest();	//实例化类对象
    24. 		Thread tA = new Thread(t,"线程一");	//以该类对象分别实例化4个线程
    25. 		Thread tB = new Thread(t,"线程二");
    26. 		Thread tC = new Thread(t,"线程三");
    27. 		Thread tD = new Thread(t,"线程四");
    28. 		tA.start();	//分别启动线程
    29. 		tB.start();
    30. 		tC.start();
    31. 		tD.start();
    32. 	}
    33. }

    运行结果：

    2、同步方法

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

    synchronized void f(){

    }

     代码案例： 

    1. package 二十章;
    2.  
    3. public class ThreadSafeTest implements Runnable{
    4. 	int num = 10;	//设置当前票数
    5. 	public synchronized void doit() {	//定义同步方法
    6. 		if(num >0) {	//设置当前票数是否大于0
    7. 			try {
    8. 				Thread.sleep(10);	//使当前线程休眠100毫秒
    9. 			}catch(InterruptedException e) {
    10. 					e.printStackTrace();
    11. 			}
    12. 			System.out.println(Thread.currentThread().getName()+"------票数"+num--);	//票数减一
    13. 		}
    14. 	}
    15. 	
    16. 	@Override
    17. 	public void run() {
    18. 		while(true) {	//设置无限循环
    19. 			doit();	//在run()方法中调用该同步方法
    20. 		}
    21. }
    22. 	
    23. 	public static void main(String[] args) {
    24. 		ThreadSafeTest t = new ThreadSafeTest();	//实例化类对象
    25. 		Thread tA = new Thread(t,"线程一");	//以该类对象分别实例化4个线程
    26. 		Thread tB = new Thread(t,"线程二");
    27. 		Thread tC = new Thread(t,"线程三");
    28. 		Thread tD = new Thread(t,"线程四");
    29. 		tA.start();	//分别启动线程
    30. 		tB.start();
    31. 		tC.start();
    32. 		tD.start();
    33. 	}
    34. }

    运行结果：

  • 相关阅读:
    【SQL报错注入】简介、相关函数、利用方法
    Qt+STK项目配置
    新品发布！无人机装调检修实训系统
    【漏洞库】Fastjson_1.2.24_rce
    android开发：安卓13Wifi和热点查看与设置功能
    宇视科技通过stm32叠加字符串
    python .gitignore文件配置
    【外卖项目实战开发四】
    基于Python的房屋租赁管理系统（附源码）
    kafka消息重复消费解决方案
  • 原文地址：https://blog.csdn.net/m0_74339463/article/details/134554818