JAVA并行-1.Java线程操作

悠扬前奏

发布于 2019-05-28 20:37:32

4460

发布于 2019-05-28 20:37:32

文章被收录于专栏：悠扬前奏的博客悠扬前奏的博客

1.进程和线程

进程（Process）是计算机中的程序关于某数据集合上的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统的基础。
面向进程的程序设计中，进程是程序的基本执行实体。
面向线程的程序设计中，进程是线程的容器。
进程是程序的实体，而程序是指令，数据，以及其组织形式的描述。

2.Java中的线程操作

2.1新建线程

2.1.2Thread线程类

关键字new创建一个线程对象，然后调用对象的start()方法：

Thread t1 = new Thread();
t1.start();

线程对象Thread有一个run()方法，start()方法会新建一个线程并让这个线程执行run()方法。
直接使用run()方法，会在当前线程中串行调用run()方法。

2.1.3Runnable接口

也可以用Runnable接口新建线程，它只有一个run()方法，而且默认的Thread.run()就是调用内部的Runnable接口，因此使用Runnable更合理。

public interface Runnable {
    public abstract void run();
}

Thread类有一个构造方法：

public Thread(Runnable target)

默认的Thread.start()方法调用的时候，新的线程就会执行Runnable.run()方法：

public void run(){
    if(target != null){
        target.run();
    }
}

以下代码实现Runnable接口，并将该实例传入Thread，避免重载Thread.run()：

public class CreateThread implements Runnable{
    public static void main(String[] args){
        Thread t1 = new Thread(new CreateThread());
        t1.start();
    }

    @Override
    public void run(){
        System.out.println("Here is a Runnable！");
    }
}

2.2 终止线程

一般来说，线程在执行完成之后就会结束。但是也可以手动关闭线程。

2.2.1Thread.stop()

Thread.stop()方法可以结束线程，但是是直接终止线程，并立即释放这个线程所持有的锁。
该方法会导致数据不一致的问题，因此已经被标注为废弃，不要使用。

例如，以下代码没有错误信息，但是结果不一致了：

public class StopThreadUnsafe {
    public static User u = new User();

    public static class User {
        int id;
        String name;

        public User() {
            id = 0;
            name = "0";
        }

        public int getId() {
            return id;
        }

        public void setId(int id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "User [id = " + id + ", name = " + name + "]";
        }
    }

    public static class ChangeObjectThread extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (u) {
                    int v = (int) (System.currentTimeMillis() / 1000);
                    u.setId(v);
                    // do something else
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    u.setName(String.valueOf(v));
                }
                Thread.yield();
            }
        }
    }

    public static class ReadObjectThread extends Thread {
        @Override
        public void run() {
            while (true) {
                synchronized (u) {
                    if (u.getId() != Integer.parseInt(u.getName())) {
                        System.out.println(u.toString());
                    }
                }
                Thread.yield();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new ReadObjectThread().start();
        while (true) {
            ChangeObjectThread t = new ChangeObjectThread();
            t.start();
            Thread.sleep(150);
            t.stop();
        }
    }
}

如果要安全的停止一个线程，可以自己决定停止线程的时机，例如将前例中的CreateObjectThread线程中增加一个stopMe()方法：

public static class ChangeObjectThread extends Thread {
        volatile boolean stopme = false;
        
        public void stopMe() {
            stopme = true;
        }
        
        @Override
        public void run() {
            while (true) {
                if(stopme) {
                    System.out.println("exit by stop me");
                    break;
                }
                synchronized (u) {
                    int v = (int) (System.currentTimeMillis() / 1000);
                    u.setId(v);
                    // do something else
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    u.setName(String.valueOf(v));
                }
                Thread.yield();
            }
        }
    }

2.3 中断线程

中断线程并不会使线程立即退出，而是给线程发送通知，线程接到通知后的操作由线程执行决定。
JVM中于线程中断有关的方法如下：
- Thread.interrupt()，是一个实例方法，通知线程中断，即设置中断标志位。中断标志位表示当前线程已经被中断了。
- Thread.isInterrupted()，也是一个实例方法，判断当前线程是否有中断（通过判断中断标志位）
- Thread.interrupted()，是一个静态方法，用来判断当前线程的中断状态，同时清除当前线程的中断状态。
方法签名为：

public void Thread.interrupt()  //中断线程
public boolean Thread.isInterrupted()  //判断线程是否中断
public static boolean Thread.interrupted() //判断是否中断，并清除当前中断状态

注意：中断后需要增加中断处理代码，不然中断不会发生作用。

Thread.sleep()函数

在循环体中，出现了sleep()或者wait()等操作，需要通过中断来识别。wait()在下一小节介绍，这里介绍sleep()方法。 Thread.sleep()函数的作用是让当前线程休眠若干时间，其函数签名为：

public static native void sleep(long millis) throws InterruptedException

它会抛出一个InterruptedException异常，不是运行时异常，程序必须捕获并处理他。当线程在sleep()休眠中被中断，这个异常就会产生。注意：Thread.sleep()方法因为中断抛出异常时，会清除中断标记，如果不加处理，在下一次循环开始时，就无法捕捉这个中断，所以在异常处理中需要再次设置中断标记位。

2.4 等待（wait）和通知（notify）

等待（wait）方法和通知（notify）方法是为了支持多线程的协作而存在的。
这两个方法是在Object类中，即任何对象都能调用这两个方法。
Object.wait()方法不能随便调用，需要包含在对应的synchronzied语句中。
wait()和notify()方法都需要首先获得目标对象的一个监视器。
Object.wait()和Thread.sleep()方法都能让线程等待若干时间，区别为：
- wait()方法可以被唤醒，sleep()方法需要等待时间结束
- wait()方法会释放目标对象的锁，而sleep()方法不会释放任何资源
其方法签名为：

public final void wait() throws InterruptedException
public final native void notify()

线程调用object.wait()方法，它会进入到object的等待队列。当object.notify()方法被调用时，对象会在线程队列中，随机选择一个线程，将其唤醒。注意：这个选择是非公平的，完全随机。使用例子：

package temp;

public class SimpleWN {
    final static Object object = new Object();
    public static class T1 extends Thread{
        public void run() {
            //获得object对象锁
            synchronized(object) {
                System.out.println(System.currentTimeMillis() + ": T1 Start!");
                try {
                    System.out.println(System.currentTimeMillis() + ": T1 is wait for obejct!");
                    // 释放object的对象锁
                    object.wait();
                }
                catch(InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(System.currentTimeMillis() + ": T1 is end");
            }
        }
    }
    
    public static class T2 extends Thread {
        public void run() {
            synchronized(object) {
                System.out.println(System.currentTimeMillis() + ": T2 Start!");
                System.out.println("notify one thread!");
                // 释放object对象锁
                object.notify();
                System.out.println(System.currentTimeMillis() + ": T2 end!");
                try {
                    // 休眠结束之后，才释放对象锁，T1才能继续执行
                    Thread.sleep(2000);
                }
                catch(InterruptedException e) {
                    e.printStackTrace();
                }
                
            }
        }
    }
    
    public static void main(String[] args) {
        Thread t1 = new T1();
        Thread t2 = new T2();
        t1.start();
        t2.start();
    }
}

2.5 挂起（suspend）和继续执行（resume）线程

被挂起（suspend）的线程，需要等到resume()操作后才能继续执行
这两个方法已经标注为废弃，不建议使用
废弃的原因是suspend()方法在导致线程暂停的同时，并不会释放任何锁资源，其他任何要范围被它暂时使用的锁，都无法正常运行。而被挂起的线程状态仍然是Runnable，影响对系统状态的判断。

以下例子会导致系统锁死：

public class BadSuspend {
    public static Object u = new Object();
    static ChangeObjectThread t1 = new ChangeObjectThread("t1");
    static ChangeObjectThread t2 = new ChangeObjectThread("t2");
    
    public static class ChangeObjectThread extends Thread{
        public ChangeObjectThread(String name) {
            super.setName(name);
        }
        
        @Override
        public void run() {
            synchronized(u) {
                System.out.println("in " + getName());
                Thread.currentThread().suspend();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException{
        // t1
        t1.start();
        Thread.sleep(100);
        t2.start();
        t1.resume();
        // 此时t2的状态依然是RUNNABLE
        t2.resume();
        t1.join();
        t2.join();
    }
}

为了达到相同的目的，可以用如下方法（使用wait()和notify()）：

public class GoodSuspend {
    public static Object u = new Object();
    
    public static class ChangeObjectThread extends Thread{
        // 标记变量，表明线程是否被挂起
        volatile boolean suspendme = false;

        public void suspendMe() {
            suspendme = true;
        }
        
        public void resumeMe() {
            suspendme = false;
            synchronized (this){
                notify();
            }
        }
        
        @Override
        public void run() {
            while(true) {
                synchronized(this) {
                    // 检查线程是否被挂起
                    while(suspendme) {
                        try{
                            wait();
                        }
                        catch(InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
                synchronized(u) {
                    System.out.println("in ChangeObjectThread");
                }
                Thread.yield();
            }
        }
    }
    
    public static class ReadObjectThread extends Thread{
        @Override
        public void run() {
            while(true) {
                synchronized(u) {
                    System.out.println("in ReadObjectThread");
                }
                Thread.yield();
            }
        }
    }
    
    public static void main(String[] args) throws InterruptedException{
        // 实例化线程对象
        ChangeObjectThread t1 = new ChangeObjectThread();
        ReadObjectThread t2 = new ReadObjectThread();
        // 运行线程对象
        t1.start();
        t2.start();
        Thread.sleep(1000);
        // 挂起t1线程
        t1.suspendMe();
        System.out.println("suspend t1 2 sec");
        Thread.sleep(2000);
        System.out.println("resume t1");
        t1.resumeMe();
    }
}

2.6 等待线程结束（join）和谦让（yield）

join签名如下，有两种：

// 阻塞当前线程，直到目标线程执行完毕
public final void join() throws InterruptedException

 // 最多等待millies毫秒，之后继续执行
public final synchronised void join(long millis) throws InterruptedException

join 的本质是调用线程wait()方法在当前线程对象实例上，它使得调用线程在当前线程对象上等待，被等待的线程会在调用结束前调用notifyAll()通知所有等待线程继续执行。JDK中join()实现的核心代码为：

while(isAlive()){
  wati(0);
}

基础join()例子：

package temp;

public class JoinMain {
    public volatile static int i = 0;

    public static class AddThread extends Thread {
        @Override
        public void run() {
            for (; i < 1000000; i++)
                ;
        }
    }

    public static void main(String[] args) throws InterruptedException {
        AddThread at = new AddThread();
        System.out.println(i);
        at.start();
        System.out.println(i);
        at.join();
        // join()保证最后输出的是1000000
        System.out.println(i);
    }
}