java 多线程实现

作者: 步积 | 来源:发表于2017-03-29 14:23 被阅读70次

一、线程的状态

线程主要有四种状态，任何一个线程必然处于这四种状态其中的一种，具体的状态及转换流程如下：

线程状态及切换流程

1. New 初始化

在这个状态下，线程被初始化，但是尚未启动，所以也无法执行，这个状态处于我们new初始化了一个线程，但是并未调用起start()函数之前。

2. Runnable 可执行状态

在支持多线程的系统中会有一个排程器，主要是可以从线程池中选择一个线程，并且将其启动执行。
当线程处于可执行状态时，表示其可能处于线程池中等待排程器来启动执行，也有可能表示其正在执行。
所以在执行了线程的start()方法后，线程就变为可执行状态，但是此时并不是一定就在执行中。

3. Dead 死亡

当线程执行结束以后，就引入死亡状态。例如，线程类中的run()函数执行完毕以后，线程就进入到死亡状态。

4. Blocked 停滞，或者说锁定状态

当线程处于锁定状态时，系统排程器会将其忽略，不对其排程。线程自行等待所需资源被释放，或者重新被调用开始执行。

二、线程间的相互作用

多个线程之间需要进行一些协调通信，共同完成一件任务。通过查询Object的Api可以发现，Object直接提供三个操作线程的方法。之所以将线程通信的三个方法放在object类中，主要原因是在java中，每个对象都是可以有锁的，锁是针对于多线程的情况，那么就需要对象有操作线程释放或者获得锁的方法。

notify() 跳转查看API说明

唤醒一个监控当前对象的线程，也就是被当前对象锁住的线程。如果有多个线程在等待被唤醒，则随机选择一个唤醒。线程能够等待对象释放锁，是因为调用了对象的wait()方法中的一个。
被唤醒的线程也不能立即开始执行，需要等到当前线程释放对象的锁。被唤醒的线程同其他等待使用该对象的线程级别相同，在同下一个想要锁定该对象的线程没有什么竞争特权。
notify()方法应当是有拥有当前对象的锁的线程调用，一个线程想要拥有对象的锁有下面三种方式之一：

通过执行对象的synchronized同步代码块方法。确保同一之间只能有一个线程执行此代码块，其他线程阻塞，知道当前代码块被执行完毕。
通过执行对象的synchronized同步代码块。
通过类对象，调用执行synchronized修饰的静态static方法。

同一时间只能有一个对象获得对象的锁。在synchronized关键字的介绍中，我们也说过，如果一个线程调用了对象中的一个synchronized代码块或synchronized方法，则对象中的所有synchronized修饰的对象都被锁，或者说获得了对象的同步锁，其他线程想要调用该对象的同步代码块或同步方法，就必须要等到当前线程执行外代码块的内容，然后释放对象锁以后才可以。此处跳转查看synchronized关键字说明

notifyAll() 跳转查看API说明

notifyAll()方法同notify()方法基本相同，不同的是notifyAll()方法一次唤醒等待该对象锁的所有线程。

wait() 跳转查看API说明

调用wait()方法可以使得当前线程进入等待状态，直到被其他的线程对这个线程调用notify()方法或者notifyAll()方法，或者在指定的时间后运行。
调用此方法的当前线程必须要拥有当前对象的锁。
调用wait()方法后，当前线程(简称T)状态会设置为等待对象并且释放对象中所有的synchronized关键字修饰的方法或方法块。线程T进入阻塞状态，直到发生下面的四种情况：

其他线程调用了此对象的nodify()方法，线程T将在随机选择的情况下被唤醒
其他线程调用了对象的nodifyAll()方法，线程T被唤醒；
其他线程中断了线程T
指定了线程的实时运行时间，或多或少。如果超时时长为0，那么就不考虑线程在一直等待知道被唤醒。

为了确保调用wait()方法的时候，线程是持有对象锁的，因此必须将wait()方法放到同步代码块或同步代码中，如下代码：

     synchronized (obj) {
         while (<condition does not hold>)
             obj.wait(timeout);
         ... // Perform action appropriate to condition
     }

wait()方法和sleep()方法区别

线程调用wait()方法时，是直接释放对象锁的，当被重新唤醒后，是需要重新跟其他想要获得锁的线程一起重新竞争获得锁的。
线程调用sleep()方法时，需要指定休眠时长，线程会休眠指定时长，在休眠的过程中，线程不会释放对象锁，休眠时间结束后，线程继续执行。

实战代码演示

定义包含使用synchronized关键字修饰方法的对象

public class NumberHolder {
    private int number;//声明计数变量

    //定义增加同步方法，使用synchronized关键字进行修饰，同一时刻只能有一个线程获得对象锁执行方法
    public synchronized void AddMethod() {
        if (number != 0) {
            try {
                System.out.println("Add " + Thread.currentThread().getName() + " wait : " + number);
                //持有当前对象锁的线程调用wait()方法，进入等待状态，释放锁
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;
        System.out.println("Add " + Thread.currentThread().getName() + " : " + number);
        //唤醒监控对象锁释放的线程列表中的随机一个线程，进入执行状态，等待获取对象锁
        notify();
    }

    //定义减数同步方法，使用synchronized关键字进行修饰，同一时刻只能有一个线程获得对象锁执行方法
    public synchronized void MinMethod() {
        if (0 == number) {
            try {
                System.out.println("Min " + Thread.currentThread().getName() + " wait : " + number);
                //持有当前对象锁的线程调用wait()方法，进入等待状态，释放锁
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println("Min " + Thread.currentThread().getName() + " : " + number);
        //唤醒监控对象锁释放的线程列表中的随机一个线程，进入执行状态，等待获取对象锁
        notify();
    }
}

定义线程对象

public class AddThread extends Thread {
    private NumberHolder numberHolder;

    public AddThread(NumberHolder numberHolder, String strThreadName) {
        this.numberHolder = numberHolder;
        this.setName(strThreadName);
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                Thread.sleep((long)(Math.random()*1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            numberHolder.AddMethod();
        }
    }
}

public class MinThread extends Thread {
    private NumberHolder numberHolder;
    public MinThread (NumberHolder numberHolder, String strThreadName) {
        this.numberHolder = numberHolder;
        this.setName(strThreadName);
    }

    @Override
    public void run() {
        for (int i = 0; i < 3; i++) {
            try {
                Thread.sleep((long)(Math.random() * 1000));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            numberHolder.MinMethod();
        }
    }
}

新起两个线程同时调用对象，实现线程调用对象的锁的实现和wait()方法和notify()方法的使用。

    public static void main(String[] args) {
        NumberHolder numberHolder = new NumberHolder();

        AddThread addThread1 = new AddThread(numberHolder, "addThread1");
        MinThread minThread2 = new MinThread(numberHolder, "minThread2");
        addThread1.start();
        minThread2.start();
    }

执行结果为 多次执行结果不同

Add addThread1 : 1
Min minThread2 : 0
Min minThread2 wait : 0
Add addThread1 : 1
Min minThread2 : 0
Min minThread2 wait : 0
Add addThread1 : 1
Min minThread2 : 0

从上述结果中，可以看出两个线程依次执行增加和减少方法，结果正确，但是如果我们将线程数量增加到四个，情况会是如何？请看代码

    public static void main(String[] args) {
        NumberHolder numberHolder = new NumberHolder();

        AddThread addThread1 = new AddThread(numberHolder, "addThread1");
        MinThread minThread2 = new MinThread(numberHolder, "minThread2");
        AddThread addThread3 = new AddThread(numberHolder, "addThread3");
        MinThread minThread4 = new MinThread(numberHolder, "minThread4");

        addThread1.start();
        minThread2.start();
        addThread3.start();
        minThread4.start();
    }

执行结果，多次执行结果不同

Min minThread2 wait : 0
Add addThread1 : 1
Min minThread2 : 0
Min minThread4 wait : 0
Add addThread3 : 1
Min minThread4 : 0
Min minThread2 wait : 0
Min minThread4 wait : 0
Add addThread3 : 1
Min minThread2 : 0
Min minThread4 : -1
Min minThread4 : -2
Add addThread1 wait : -2
Min minThread2 : -3
Add addThread1 : -2
Add addThread1 wait : -2
Add addThread3 wait : -2

当两个线程的时候，线程顺序切换，数据正常，但是当线程数量增加到四个的时候，执行结果就发生了错误。
判断错误的原因可能是由于在两个线程时，一个执行，一个在wait，因此当增加的线程运行时，减少的线程在等待，当增加的线程调用modify后，唤醒的就是减少的线程，因此数据正确。
而在四个线程的时候，当前线程在运行时，调用nodify唤醒的可能是如下情况的三种进程

从未开始执行的线程，因为没有获得对象锁，而直接进入等待状态的；
获得过对象锁，且执行结束，释放锁之后进入等待状态的；
获得过对象锁，执行时条件不满足，调用了wait方法进入等待状态的；

这三种情况下的进程都有可能是增加或者减少，如果连续两次唤醒的都是减少的存储过程，且可能有减少的存储过程是调用了wait方法进入等待状态的，在num已经等于0，或者小于0的情况下，继续执行方法，对number值进行减少，导致出现-1甚至是-2的情况。
解决这种问题的方法很简单，就是避免某个线程是执行到wait方法时进入等待状态的，重新唤醒时没有进行number值的判断，就直接执行number值操作的情况。可以将if直接修改为while即可，代码如下：

public class NumberHolder {
    private int number;//声明计数变量

    //定义增加同步方法，使用synchronized关键字进行修饰，同一时刻只能有一个线程获得对象锁执行方法
    public synchronized void AddMethod() {
        while (number != 0) {
            try {
                System.out.println("Add " + Thread.currentThread().getName() + " wait : " + number);
                //持有当前对象锁的线程调用wait()方法，进入等待状态，释放锁
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number++;
        System.out.println("Add " + Thread.currentThread().getName() + " : " + number);
        //唤醒监控对象锁释放的线程列表中的随机一个线程，进入执行状态，等待获取对象锁
        notify();
    }

    //定义减数同步方法，使用synchronized关键字进行修饰，同一时刻只能有一个线程获得对象锁执行方法
    public synchronized void MinMethod() {
        while (0 == number) {
            try {
                System.out.println("Min " + Thread.currentThread().getName() + " wait : " + number);
                //持有当前对象锁的线程调用wait()方法，进入等待状态，释放锁
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        number--;
        System.out.println("Min " + Thread.currentThread().getName() + " : " + number);
        //唤醒监控对象锁释放的线程列表中的随机一个线程，进入执行状态，等待获取对象锁
        notify();
    }
}

while方法体，在条件不满足的时候，会循环执行，直至满足条件才会结束循环

参考地址：http://www.cnblogs.com/weiguo21/p/4813611.html

java 多线程实现

一、线程的状态

1. New 初始化

2. Runnable 可执行状态

3. Dead 死亡

4. Blocked 停滞，或者说锁定状态

二、线程间的相互作用

notify() 跳转查看API说明

notifyAll() 跳转查看API说明

wait() 跳转查看API说明

wait()方法和sleep()方法区别

实战代码演示

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读

java技术基础

安卓基础知识

Java学习笔记