第二十章多线程

当程序同时完成多件事情时，就是所谓的多线程。

20.1线程简介

Windows 操作系统的执行模式。一个线程则是进程中的执行流程，一个进程中可以同时包括多个线程，每个线程也可以得到一小段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。在单线程中，程序代码按调用顺序依次往下执行。如果需要一个进程同时完成多段代码的操作，就需要使用多线程。

20.2创建线程 

两种方式：

1继承Java.lang.Thread类

2实现Java.lang.Runnable接口

20.2.1继承Thread类

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

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

继承 Thread 类创建一个新的线程的语法如下:
public class ThreadTest extends Thread{}

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 t = new ThreadTest();
        t.start();
    }
}

20.2.2实现Runnable接口

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

public class Thread extends Object implements Runnable

import java.awt.Container;
import javax.swing.*;

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); 
            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) {
        new SwingAndThread();
    }
}

运行结果：

20.3线程的生命周期 

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

20.4操作线程的方法 

20.4.1线程的休眠

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

try{

Thread.sleep(2000)；

}catch(interruptedException e）{

e.printStackTrace(): 

} 

import java.awt.*;
import java.util.Random;
import javax.swing.*;

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); 
                    } 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) {
        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);
    }
}

 

20.4.2线程的加入 

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

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);
       
        threadA = new Thread(new Runnable() {
            int count = 0;

            public void run() { 
                while (true) {
                    progressBar.setValue(++count);
                    try {
                        Thread.sleep(100); 
                        threadB.join(); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        threadA.start(); 
        threadB = new Thread(new Runnable() {
            int count = 0;

            public void run() {
                while (true) {
                    progressBar2.setValue(++count); 
                    try {
                        Thread.sleep(100); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    if (count == 100) 
                        break; 
                }
            }
        });
        threadB.start(); 
}
}

 

20.4.3线程的中断

以往有的时候会使用 stop（）方法停止线程，但当前版本的JDK 早已废除了 stop（）方法，不建议使用stop（）方法来停止一个线程的运行。现在提倡在 run（）方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。
如果线程是因为使用了 sleep0或 while（）方法进入了就绪状态，可以使用 Thread 类中 interrupt（）方法使线程离开 run（）方法，同时结束线程，但程序会抛出InterruptedException 异常，用户可以在处理该异常时完成线程的中断业务处理，如终止 while 循环。  

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);
                    } catch (InterruptedException e) { 
                        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);
    }
}

 

20.4.4线程的礼让 

Thread 类中提供了一种礼让方法，使用 yield0方法表示，它只是给当前正处于运行状态的线程一个提醒，告知它可以将资源礼让给其他线程，但这仅是一种暗示，没有任何一种机制保证当前线程会将资源礼让。
yield（）方法使具有同样优先级的线程有进入可执行状态的机会,在当前线程放弃执行权时会再度回到就绪状态。对于支持多任务的操作系统来说，不需要调用 yield0方法，因为操作系统会为线程自动分配CPU时间片来执行。

20.5线程的优先级

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

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);
        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);
        a.start();
        b.start();
        c.start();
        d.start();
    }
}

 

20.6线程同步 

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

20.6.1线程安全

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

20.6.2线程同步机制 

1，同步块

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

}

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

public class SynchronizedTest 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) {
       
        SynchronizedTest t = new SynchronizedTest();
       
        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();
    }
}

 

2.同步方法

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

}

当某个对象调用了同步方法时，该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为 synchronized，否则就会出错。 

    int num = 10; 

    public Synchronized void doit() {
                if (num > 0) { 
                    try {
                        Thread.sleep(10); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                   
                    System.out.println(Thread.currentThread().getName() + "票数" + num--);
                }
            }
        
 

    public  void run(){
    while(true){
    doit();
}
}