Java面向对象编程-第13章学习笔记

第13章 多线程

进程是指运行中的应用程序，每个进程都有自己独立的内存空间。线程是指进程中的一个执行流程。当进程内的多个线程同时运行，则称为并发运行。线程与进程的主要区别在于：每个进程都需要操作系统为其分配独立的内存空间，而同一进程内的线程则在同一块地址空间中工作。
一、Java线程的运行机制
Java虚拟机进程中，执行代码的任务由线程完成。
每个线程都有一个独立的程序计数器和方法调用栈（method invocation stack)：（1）程序计数器：当线程执行一个方法时，程序计数器指向方法区中下一条要执行代码的字节码。（2）方法调用栈：用来跟踪线程运行中的方法调用过程，栈中的元素称为栈帧。每当线程调用一个方法，则向其中压入一个新的栈帧。栈帧存储方法的参数、局部变量和运算过程中的临时数据。栈帧由三部分组成：局部变量区（存放局部变量和方法参数）、操作数栈（线程的工作区，存放运算过程中临时数据）、栈数据区（为线程执行指令提供相关信息）。
除了方法调用栈所处的栈区之外，运行时数据区还包括堆区和方法区：（1）堆区存放线程所操纵的以对象形式存放的数据，比如一个新创建的实例对象以及其成员变量和属性等。（2）方法区存放的是方法的字节码。
二、线程的创建和启动
创建线程有两种方式：扩展java.lang.Thread类和继承Runnable接口。
1、扩展java.lang.Thread类
Thread类表示线程类，包括两个主要方法：（1）run()：包含线程运行时所执行的代码；（2）start()：用于启动线程。
注意：Thread类的run()方法没有声明抛出异常，因此其子类的run()也不能声明抛出异常。

/*
 * 当执行该程序时，Java虚拟机先创建并启动主线程
 * 主线程的任务是执行main()方法
 * main()方法创建了一个Machine类的实例对象
 * 再在main()方法中通过machine调用其start()方法
 * 随即进入machine线程，执行其run()方法
 */

public class Machine extends Thread{
    public void run(){
        for(int a=0;a<50;a++)
            System.out.println(a);
    }

    public static void main(String[] args){
        Machine machine=new Machine();
        machine.start();
    }
}

/*
 * 主线程与用户自定义的线程并发运行
 */
public class Machine extends Thread{
    public void run(){
        for(int a=0;a<20;a++){
            System.out.println(currentThread().getName()+":"+a);
            try{
                sleep(100);
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args){
        Machine machine1=new Machine();
        Machine machine2=new Machine();
        machine1.start();
        machine2.start();
        machine1.run();  //这里属于主线程，main()方法通过machine1调用其run()方法
    }
}

/*
 * 主线程和machine线程共同操作machine对象的实例变量a
 */
public class Machine extends Thread{
    private int a=0;
    public void run(){
        for(a=0;a<20;a++){
            System.out.println(currentThread().getName()+":"+a);
            try{
                sleep(100);
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args){
        Machine machine=new Machine();
        machine.start();
        machine.run();  //这里属于主线程，main()方法通过machine1调用其run()方法
    }
}

注意：因为start()方法是用于启动线程，因此在Thread类的子类中不要轻易覆盖start()方法。
对于：

//该代码执行仍属于主线程
//new语句只是在堆区创建了一个包括实例变量a的Machine类的实例对象
Machine machine=new Machine();
//只有当执行start()方法后，才会启动Machine线程
//并在java栈区为其创建相应的方法调用栈
machine.start();

如果一定要在子类中覆盖start()方法可以在重写代码中首句加上”super.start()”。

注意：一个线程只能被启动一次。

2、实现Runnable接口
Java中一个类只能继承一个父类，当继承Thread类后无法继承其他类，因此Java提供了Runnable接口，实现了创建线程的第二种方式。

/*
 * 通过Runnable接口实现线程
 * 主线程中先创建一个实现接口的类的实例对象
 * 再以该对象为参数创建两个线程并启动
 * 因为t1和t2均依赖于同一个实例对象，因此他们共享machine的实例变量a
 */
public class Machine implements Runnable {
    private int a=0;
    public void run(){
        for(a=0;a<20;a++){
            System.out.println(Thread.currentThread().getName()+":"+a);
            try{
                Thread.sleep(200);
            }catch(InterruptedException e){
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) {
        Machine machine=new Machine();
        Thread t1=new Thread(machine);
        Thread t2=new Thread(machine);
        t1.start();
        t2.start();
    }
}

三、线程的状态转换
1、新建状态
当通过new语句创建线程对象时，该线程对象处于新建状态，仅仅在堆区被分配了内存。
2、就绪状态
当一个线程对象创建后，其他线程调用其start()方法，则该线程进入就绪状态，java虚拟机会为其创建方法调用栈和程序计数器。处于就绪状态的线程位于可运行池，等待获得CPU使用权。
3、运行状态
处于运行状态的线程占用CPU，执行程序代码。对于只有一个CPU的计算机，任意时刻只有一个线程处于运行状态。
4、阻塞状态
阻塞状态是指线程因为某种原因放弃CPU，暂停运行。当线程处于阻塞状态时，Java虚拟机不会给该线程分配CPU，直到其重新进入就绪状态，才有机会进入运行状态。阻塞状态分为3种：（1）位于对象等待池中的阻塞状态：当线程处于运行状态时，当执行了某个对象的wait()方法，JVM就会把线程放到这个对象的等待池中。（2）位于对象锁池中的阻塞状态：当线程处于运行状态，试图获得某个对象的同步锁时，如果该对象的同步锁已经被其他线程占用，JVM就会把这个线程放到这个对象的锁池中。（3）其他阻塞状态：比如当前线程执行了sleep()方法或者调用了其他线程的join()方法，或者发出了I/O请求。
5、死亡状态
当线程退出run()方法则进入死亡状态，该线程结束生命周期。有可能正常执行完run()方法，也有可能遇见异常而退出。Thread类的isAlive()方法判断一个线程是否活着，当其死亡或者处于新建状态时，返回false，其余返回true。

四、线程调度
计算机的单个CPU在任意时刻只能执行一条机器指令，每个线程只有获得CPU的使用权才能执行指令。Java虚拟机负责线程调度，即按照抢占式调度模型为多个线程分配CPU使用权。JVM优先让处于就绪状态的线程中优先级高的线程占用，如果多个线程优先级相同，则虚拟机随机分配。
处于运行状态的线程会一直运行，直到不得不放弃CPU，一般有以下几个原因：
（1）JVM让当前线程暂时放弃CPU，转到就绪状态。
（2）当前线程因为某些原因进入阻塞状态。
（3）当前线程运行结束。
如果希望明确让一个线程给另外一个线程运行的机会，可以采取：（1）调整各个线程的优先级；（2）让处于运行状态的线程调用Thread.sleep()方法；（3）让处于运行状态的线程调用Thread.yield()方法；（4）让处于运行状态的线程调用另一个线程的join()方法。
1、调整各个线程的优先级
Thread类有3个静态常量用来表示线程优先级：
（1）MAX_PRIORITY:取值为10，表示最高优先级；
（2）MIN_PRIORITY:取值为1，表示最低优先级；
（3）NORM_PRIORTY:取值为5，表示默认优先级。

//我这里测试居然实现不了优先...
public class Machine extends Thread{
    private static StringBuffer log=new StringBuffer();
    private static int count=0;

    public void run(){
        for(int a=0;a<20;a++){
            log.append(currentThread().getName()+":"+a+" ");
            if(++count%10==0)
                log.append("\n");
        }
    }

    public static void main(String[] args) throws Exception{
        Machine machine1=new Machine();
        Machine machine2=new Machine();
        machine1.setName("m1");
        machine2.setName("m2");
        machine2.setPriority(Thread.MAX_PRIORITY);
        machine1.setPriority(Thread.NORM_PRIORITY);
        machine1.start();
        machine2.start();

        Thread.sleep(2000);
        System.out.println(log);
    }
}

2、线程睡眠：Thread.sleep()方法
当一个线程在运行中执行了sleep()方法，它就会放弃CPU，转到阻塞状态。当结束睡眠（睡眠时间结束）时，将转到就绪状态。
线程在睡眠时如果被中断，会收到InterruptedException异常。

//主线程启动Sleeper线程
//Sleeper线程睡眠5秒钟
//主线程睡眠500毫秒后中断Sleeper线程的睡眠
public class Sleeper extends Thread{
    public void run(){
        try{
            sleep(5000);
            System.out.println("sleep over!");
        }catch(InterruptedException e){
            System.out.println("sleep interrupted");
        }
        System.out.println("End!");
    }

    public static void main(String[] args) throws Exception {
        Sleeper sleeper=new Sleeper();
        sleeper.start();
        Thread.sleep(500);
        sleeper.interrupt();
    }
}

3、线程让步：Thread.yield()方法
当线程执行yield()方法时，如果此时有与该线程相同优先级的其他线程处于就绪状态，那么yield()方法将把当前线程转入就绪状态（放入可运行池中）并使另一个同等优先级线程运行。如果没有相同优先级的线程，则yield()什么都不做。
yield()方法与sleep()方法的区别：
（1）yield只给可运行池中具有相同优先级的线程机会，而sleep()方法不考虑其他线程优先级，只是让当前线程睡眠。
（2）线程执行yield()方法后转入就绪状态，而sleep()转入阻塞状态。
（3）sleep()会抛出interruptedException,而yield()没有声明抛出异常。
4、等待其他线程结束：join()方法
当前运行的线程可以调用另外一个线程的join()方法，当前线程将转入阻塞状态，直至另一个线程运行结束，它才由阻塞状态转入就绪状态。

public class Machine extends Thread{
    public void run(){
        for(int a=0;a<20;a++)
            System.out.println(getName()+":"+a);
    }

    public static void main(String[] args) throws InterruptedException {
        Machine machine1=new Machine();
        machine1.setName("m1");
        machine1.start();
        System.out.println("Main:join The Machine1!");
        machine1.join();
        System.out.println("Main:End!");
    }
}

join()方法有两种重载形式：
（1）public void join();
（2）public void join(long timeout);//timeout设定阻塞时间
当阻塞时间超过timeout或者加入的线程运行结束时，调用线程恢复运行。

五、获得当前线程对象的引用
Thread类的currentThread()静态方法返回当前线程对象的引用。

public class Machine extends Thread{
    public void run(){
        for(int a=1;a<4;a++){
            System.out.println(currentThread().getName()+"："+a);
            yield();
        }
    }

    public static void main(String[] args) {
        Machine machine=new Machine();
        machine.setName("mac");
        machine.start();  //属于machine线程
        machine.run();    //属于main线程下的machine对象
    }
}

运行结果如下：

main：1
mac：1
main：2
mac：2
main：3
mac：3

如果把上面代码中的currentThread.getName()改成this.getName()，则this指代的是当前对象，而非当前线程。运行结果如下：

mac：1
mac：1
mac：2
mac：2
mac：3
mac：3

六、后台线程
后台线程是指为其他线程提供服务的线程，也称为守护线程。
调用Thread类的setDaemon(true)可以把一个线程设置为后台线程。只有所有前台线程都结束后，后台线程才会结束。
主线程默认为前台线程，由前台线程创建的线程默认也是前台线程。

/*
 * 功能：Machine线程是前台线程，负责将其实例变量a不断增1
  *在Machine线程start()方法中创建了一个匿名线程类，并将其实例设为后台线程
  *该后台线程定期（每隔5毫秒）把Machine对象实例变量a设为0
  */
/*执行描述
 * 1、main中先创建Machine类的实例machine,并为之命名
 * 2、执行Machine类的start()以启动machine线程
 * 3、执行Machine类的run()方法
 * 3.1进入run()方法中while代码体，打印输出，a自增，判断if，再执行yield()
 * 3.2执行yield后继续转入Machine的start()方法体内的daemon部分
 * 3.3执行daemon线程，
 * 3.4reset()。然后sleep()转入阻塞状态;
 * 3.5转入machine线程
 * 4、依次循环
 * 4.1直至machine中计数器达到2000,machine线程结束
 * 4.2每隔5毫秒daemon被唤醒转入就绪状态，当machine中yield()执行后其获得CPU然后再回到3.4
 */
public class Machine extends Thread{
    private int a;
    private static int count;
    public void start(){
        super.start();
        Thread daemon=new Thread(){
            public void run(){
                while(true){
                    reset();
                    try{
                        sleep(5);
                    }catch(InterruptedException e){
                        throw new RuntimeException();
                    }                   
                }
            }
        };
        daemon.setDaemon(true);
        daemon.start();
    }

    public void reset(){a=0;}
    public void run(){
        while(true){
            System.out.println(getName()+":"+a+"--"+count);
            a++;
            if(count++==2000)   break;
            yield();
        }
    }

    public static void main(String[] args) throws Exception{
        Machine machine=new Machine();
        machine.setName("m1");
        machine.start();  
    }
}

七、定时器Timer
在JDK的java.util包中提供了Timer类，可以定时执行任务。TimerTask类表示定时器执行的一项任务，是一个抽象类，实现了Runnable接口。

八、线程同步
线程的同步是为了防止多个线程访问一个数据对象时，对数据产生的破坏。
每个Java对象只有一个同步锁，任何时候只允许一个线程拥有这把锁。（1）假如这个锁已经被其他线程使用，JVM就会把其他线程放到对象锁池中，这些线程进入阻塞状态。等到锁释放的时候，JVM会从锁池中随机选取一个线程占有这个锁，并转到就绪状态。（2）加入这个锁没有被其他线程使用，当前调用者线程就会获得这个锁，并开始执行同步代码块。（3）一般情况下，只有当同步代码块执行完毕才会释放锁。（4）如果一个方法中所有代码都是同步代码，则可以修饰这个方法为synchronized。（5）同步代码块和中断方式并不矛盾，同步代码快中也可以执行sleep()和yield()方法，但此时并没有释放锁，只是暂时放弃了CPU。（6）synchronized声明不会被继承。
例：（同步与并发）

/*
 * 3个人打水，每个人打十桶水，依次打水
 * 每个人都需要等前面人打完10桶水才开始
 * 注意synchronized的位置
 */
public class Person extends Thread{
    private Well well;
    public Person(Well well){
        this.well=well;
    }
    public void run(){
        synchronized(well){   //针对对象well的同步代码
            for(int i=0;i<10;i++){ //打10桶水
                well.withdraw();
                yield();
            }           
        }
    }

    public static void main(String[] args){
        Well well=new Well();
        Person person[]=new Person[3];
        for(int i=0;i<3;i++){  //创建10个Person线程
            person[i]=new Person(well);
        }
        person[0].start();
        person[1].start();
        person[2].start();
    }
}

/*
 * 改为对Well类withdraw()方法修饰为synchronized
 * 注意synchronized的位置
 */
public class Person extends Thread{
    private Well well;
    public Person(Well well){
        this.well=well;
    }
    public void run(){
        for(int i=0;i<10;i++){ //打10桶水
            well.withdraw();
            yield();
        }           
    }

    public static void main(String[] args){
        Well well=new Well();
        Person person[]=new Person[3];
        for(int i=0;i<3;i++){  //创建10个Person线程
            person[i]=new Person(well);
        }
        person[0].start();
        person[1].start();
        person[2].start();
    }
}


public class Well {
    private int water=1000;
    public synchronized void withdraw(){  //打一桶水
        water--;
        System.out.println(Thread.currentThread().getName()+": water left:"+water);
    }
}

一个线程安全的类需要满足以下条件：
（1）、这个类的对象可以同时被多个线程安全的访问。
（2）每个线程都能正常执行原子操作，得到正确结果。
（3）每个线程的原子操作完成后，对象处于逻辑合理状态。

在以下情况下，持有锁的线程会释放锁：
（1）执行玩同步代码块；
（2）执行同步代码块过程中，遇到异常而导致线程终止；
（3）执行同步代码块中，执行了锁所属对象的wait()方法。

九、线程通信
不同线程执行不同的任务，如果这些任务需要某种联系，则线程之间必须可以通信以确保任务达成，比如生产者和消费者之间，需要实现知道库存。java.lang.Object提供了两种线程通信的方法：
（1）wait():执行该方法的线程释放对象的锁，Java虚拟机把该线程放入对象等待池，该线程等待其他线程将它唤醒。
（2）notify()：执行该方法的线程唤醒在对象等待池中等待的某个线程，JVM会从等待池中随机选择一个线程。
假设t1和t2两个线程共同操纵一个s对象，通信流程如下：（1）t1执行s的一个同步代码块时，t1持有s的锁，t2在s的锁池中等待；（2）t1在同步代码块中执行s.wait()方法,t1释放s的锁，进入对象s的等待池；（3）在对象s锁池中等待的t2获得了s的锁，执行s的另一个同步代码块；（4）t2在同步代码块中执行s.notify()方法，JVM把t1线程从对象s的等待池中移到s的锁池中，等待获得锁；（5）t2线程执行完同步代码块，释放锁，t1获得锁，继续执行其同步代码块。