【Java笔记】多线程

1、创建线程

创建线程的方式有两种：
通过创建Thread类的子类来实现；
通过实现Runnable接口的类来实现。

class Test extends Thread {
    String s;
    int m, count = 0;

    Test(String ss, int mm) {
        s = ss;
        m = mm;
    }

    public void run() {
        try {
            while (true) {
                System.out.print(s);
                sleep(m);
                count++;
                if (count >= 20)
                    break;
            }
            System.out.println(s + "finished !");
        } catch (InterruptedException e) {
            return;
        }
    }

    public static void main(String args[]) {
        Test threadA = new Test("A  ", 2);
        Test threadB = new Test("B  ", 1);
        threadA.start();
        threadB.start();
    }
}

class Test implements Runnable {
    String s;
    int m, count = 0;

    Test(String ss, int mm) {
        s = ss;
        m = mm;
    }

    public void run() {
        try {
            while (true) {
                System.out.print(s);
                Thread.sleep(m);
                count++;
                if (count >= 20)
                    break;
            }
            System.out.println(s + "finished !");
        } catch (InterruptedException e) {
            return;
        }
    }

    public static void main(String args[]) {
        Test threadA = new Test("A  ", 2);
        Test threadB = new Test("B  ", 1);
        Thread threadC=new Thread(threadA);
        Thread threadD=new Thread(threadB);
        threadC.start();
        threadD.start();
    }
}

2、线程的优先级

线程在创建时，继承了父类的优先级。线程创建后，可以在任何时刻调用setPriority方法改变线程的优先级。优先级为1～10，Thread定义了其中3个常数：
MAX_PRIORITY最大优先级（值为10）；
MIN_PRIORITY最小优先级（值为1）；
NORM_PRIORITY默认优先级（值为5）

3、线程的常用方法

start() ：线程调用该方法将启动线程，使之从新建状态进入就绪队列排队，一旦轮到它来享用CPU资源时，就可以脱离创建它的线程独立开始自己的生命周期了。

run()：线程对象被调度之后所执行的操作，由系统自动调用，用户程序不得引用。系统的Thread类中，run()方法没有具体内容，所以用户程序需要创建自己的Thread类的子类，并重写run()方法来覆盖原来的run()方法。当run方法执行完毕，线程就变成死亡状态。

sleep(int millsecond)：线程占有CPU期间，执行sleep方法来使自己放弃CPU资源，休眠一段时间。如果线程在休眠时被打断，JVM就抛出InterruptedException异常。因此，必须在try~catch语句块中调用sleep方法。

isAlive()：线程处于运行状态时， isAlive()方法返回true，否则返回false。

currentThread()：是Thread类中的类方法，可以用类名调用，该方法返回当前正在使用CPU资源的线程。

interrupt()：用来“吵醒”休眠的线程。

例题：

有两个线程：student和teacher，其中student准备睡一小时后再开始上课，teacher在输出3句“上课”后，吵醒休眠的线程student.

import java.util.logging.Level;
import java.util.logging.Logger;

public class ThreadDemo {
    Thread student,teacher;
    class Student extends Thread {

        public void run() {
            try {
                System.out.println("学生张三正在睡觉！");
                this.sleep(1000 * 60 * 60);
            } catch (InterruptedException ex) {
                System.out.println("学生张三醒了！");
                System.out.println("学生张三起来听课了！");
            }
        }
    }
    class Teacher extends Thread {

        public void run() {
            try {
                for (int i = 0; i < 3; i++) {
                    System.out.println("上课！");
                    this.sleep(500);
                }
                student.interrupt();
            } catch (InterruptedException ex) {
                Logger.getLogger(Teacher.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
    ThreadDemo(){
        teacher = new Teacher();
        student = new Student();
    }
    public static void main(String args[]) {
        ThreadDemo t  = new ThreadDemo();
        t.student.start();
        t.teacher.start();
      }
}

4、线程同步

Java提供了多线程机制，通过多线程的并发运行可以提高系统资源利用率，改善系统性能。但在有些情况下，一个线程必须和其他线程合作才能共同完成任务。线程可以共享内存，利用这个特点可以在线程之间传递信息。

在Java中，实现同步操作的方法是在共享内存变量的方法前加synchronized修饰符。在程序运行过程中，如果某一线程调用经synchronized修饰的方法，在该线程结束此方法的运行之前，其他所有线程都不能运行该方法，只有等该线程完成此方法的运行后，其他线程才能运行该方法。

在同步方法中使用wait()、notify 和notifyAll()方法：等待与通知一个线程在使用的同步方法中时，可能根据问题的需要，必须使用wait()方法使本线程等待，暂时让出CPU的使用权，并允许其它线程使用这个同步方法。其它线程如果在使用这个同步方法时如果不需要等待，那么它用完这个同步方法的同时，应当执行notifyAll()方法通知所有的由于使用这个同步方法而处于等待的线程结束等待。