第二十章，多线程

创建线程

有两种方式，分别为继承Java.lang.Thread类与实现Java.lang.Runnable接口

继承Thread类

Thread常用的两个构造方法语法

public Thread（）；

public Thread（String threadName）；

继承Thread类创建新线程语法：

public class ThreadTest extend Thread{

}

完成线程功能的代码放在类的run（）方法中，当类继承Thread类后，就要在类中覆盖run（）方法，将实现该线程功能代码写入，然后调用Thread类中的start（）方法执行

语法：

public void run(){

}

例题1

package 例题;public class 例题1 extends Thread{public void run() {//重写方法for(int i = 0; i < 10; i++) {System.out.print(i + " ");}}public static void main(String[] args) {例题1 th = new 例题1();th.start();//启动线程}}

结果

实现Runnable 接口

到目前为止，线程都是通过扩展Thread类来创建的，如果本类需要继承其他类而且要实现多线程，那么就可以通过Runnable接口来实现

语法：

public class 类名 implements Runnable{

}

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

public 类名（Runnable target）

public 类名（Runnable target，String name）

这两个构造方法的参数都有Runnable实例，使用以上构造方法就可以将Runnable实例与Thread实例相关联

使用Runnable接口创建新线程步骤

1.建立Runnable对象

2.使用参数为Runnable对象的构造方法创建Thread实例

3.调用start（）方法启动线程

例题2

package 例题;import java.awt.Container;import javax.swing.*;public class 例题2 extends JFrame{//图标横坐标int count = 0;public 例题2() {setBounds(300,200,315,100);//窗体位置大小Container con = getContentPane();//主容器con.setLayout(null);//窗体不使用任何布局管理Icon ic = new ImageIcon("src/1.gif");//导入图片JLabel jl = new JLabel(ic);//显示图标标签jl.setBounds(10, 10, 200, 50);//图标位置大小Thread t = new Thread() {//定义匿名线程对象@Overridepublic void run() {while(true) {jl.setBounds(count, 10, 200, 50);//将坐标用变量显示try {Thread.sleep(50);//使线程休眠50秒}catch(InterruptedException e) {e.printStackTrace();}count += 4;//每次坐标加4if(count >= 200) {//如果坐标达到200就回到原位置count = -100;}}}};t.start();//启动线程con.add(jl);//将标签加入容器中setVisible(true);//使窗体可见setDefaultCloseOperation(EXIT_ON_CLOSE);//窗体关闭方式}public static void main(String[] args) {new 例题2();}}

结果

启动一个新线程不是直接调用Thread子类对象的run方法，而是调用Thread子类的start（）方法

Thread类的start（）方法产生一个新线程，该线程运行子类的run（）方法

线程的生命周期

操作线程的方法

线程的休眠

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

语法：

try{

Thread.sleep（2000）；

}catch（InterruptedException e）{

e.printStackTrace（）；

}

例题3

package 例题;import java.awt.Color;
import java.awt.Graphics;
import java.util.Random;import javax.swing.JFrame;public class 例题3 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 例题3() {setBounds(550,300,0,0);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 g = getGraphics();//获取组件绘制上下文对象g.setColor(getC());//设置绘图颜色g.drawLine(x, y, 100, y++);//绘制线程并递增垂直坐标if(y >= 300) {y = 100;}}}});t.start();//启动线程}public static void main(String[] args) {init(new 例题3(), 200, 200);}private static void init(JFrame frame, int iwidth, int height) {//初始化程序界面方法frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);frame.setSize(iwidth, height);frame.setVisible(true);}}

结果

线程的加入

jion（）方法

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

例题4

package 例题;import java.awt.BorderLayout;import javax.swing.JFrame;
import javax.swing.JProgressBar;public class 例题4 extends JFrame{//定义两个线程private Thread threadA;private Thread threadB;//定义两个进度条组件private JProgressBar pr = new JProgressBar();private JProgressBar pr1 = new JProgressBar();public static void main(String[] args) {例题4 l = new 例题4();l.setVisible(true);}public 例题4() {setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);setBounds(200, 200, 200, 100);//窗口位置大小getContentPane().add(pr, BorderLayout.NORTH);//将进度条设置在窗体最北面getContentPane().add(pr1, BorderLayout.SOUTH);//将进度条设置在窗体最南面pr.setStringPainted(true);//设置进度条显示数字字符pr1.setStringPainted(true);threadA = new Thread(new Runnable() {//使用匿名内部类形式初始化Thread实例int count = 0;public void run() {//重新方法while(true) {pr.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) {pr1.setValue(++count);//设置进度条当前值try {Thread.sleep(100);//使线程休眠100毫秒}catch(InterruptedException e) {e.printStackTrace();}if(count == 100)//当变量为100时跳出循环break;}}});threadB.start();//启动线程b}
}

结果

线程的中断

Interrupt（）方法

该方法可以使线程离开run()方法，同时结束线程但程序会抛出InterruptedException异常，用户可以在处理该异常时完成线程的中断业务处理，如终止while循环。

例题5

package 例题;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 例题5 extends JFrame{public 例题5() {JProgressBar pr = new JProgressBar();//创建进度条getContentPane().add(pr, BorderLayout.NORTH);//将进度条放在窗体合适位置JButton but = new JButton("停止");getContentPane().add(but , BorderLayout.SOUTH);pr.setStringPainted(true);//显示进度条位置Thread t = new Thread(new Runnable() {int count = 0;public void run() {while(true) {pr.setValue(++count);//设置进度条当前值try {Thread.sleep(100);//使线程休眠100秒}catch (InterruptedException e) {System.out.println("当前线程序被中断");//捕捉InterruptedException异常break;}}}});but.addActionListener(new ActionListener() {public void actionPerformed(ActionEvent e) {t.interrupt();//中断线程}});t.start();//启动线程}private static void init(JFrame fe, int widht, int height) {fe.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);fe.setSize(widht, height);fe.setVisible(true);}public static void main(String[] args) {init(new 例题5(),100,100);}}

结果

线程的礼让

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

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

线程的优先级

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

Thread类中包含的成员变量代表了线程的某些优先级，如Thread.MIN_PRIORITY（常数1）、Thread.MAXPRIORITY（常数10)、Thread.NORM PRIORITY（常数5）。其中，每个线程的优先级都在 Thread.MIN_PRIORITY~Thread.MAX_PRIORITY，在默认情况下其优先级都是Thread.NORM PRIORITY。每个新产生的线程都继承了父线程的优先级。

在多任务操作系统中，每个线程都会得到一小段CPU时间片运行，在时间结束时，将轮换另一个线程进入运行状态，这时系统会选择与当前线程优先级相同的线程予以运行。系统始终选择就绪状态下优先级较高的线程进入运行状态。处于各个优先级状态下的线程的运行顺序如图20.8所示。

在图20.8中，优先级为5的线程A首先得到CPU时间片；当该时间结束后，轮换到与线程A相同优先级的线程B；当线程 B的运行时间结束后，会继续轮换到线程A，直到线程A与线程B都执行完毕，才会轮换到线程C；当线程C结束后，才会轮换到线程D。

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

例题6

package 例题;public class 例题6 implements Runnable{String name;public 例题6(String name) {this.name = name;}@Overridepublic void run() {//完成5万次字符串拼接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 例题6("A"));a.setPriority(1);Thread b = new Thread(new 例题6("B"));b.setPriority(3);Thread c = new Thread(new 例题6("C"));c.setPriority(7);Thread d = new Thread(new 例题6("D"));d.setPriority(10);a.start();//启动线程b.start();c.start();d.start();}
}

结果

线程同步机制

1.同步块

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

synchronized(Object) {
}

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

例题7

package 例题;public class 例题7 implements Runnable{int num = 10;//设置总票数@Overridepublic void run() {while(true) {//设置无限循环synchronized (this) {//设置同步代码块if(num > 0) {//判断票数是否大于0try {Thread.sleep(100);//使线程休息100秒}catch (InterruptedException e) {e.printStackTrace();}System.out.println(Thread.currentThread().getName() + "----票数" + num--);}}}}public static void main(String[] args) {例题7 s = new 例题7();//实例化对象Thread s1 = new Thread(s,"线程1");//实例化线程Thread s2 = new Thread(s,"线程2");Thread s3 = new Thread(s,"线程3");Thread s4 = new Thread(s,"线程4");s1.start();//启动线程s2.start();s3.start();s4.start();}}