Java多线程编程

进程与线程

  • 在Java语言里面最大的特点是支持多线程的开发（也是为数不多支持多线程的编程语言）；
  • 如果要想理解线程，那么首先就需要了解一下进程的概念，在传统的DOS系统的时代，其本身有一个特征：如果你电脑上出现了病毒，那么所有的程序将无法执行，因为传统的DOS采用的是单进程处理，而单进程最大的特点：在同一个时间段上只允许一个程序在执行；
  • 线程是在进程基础上划分的更小的程序单元，线程是在进程基础上创建并使用的，所以线程依赖于进程的支持，但是线程的启动速度要比进程快很多，所以当使用多线程进行并发处理的时候，其执行的性能要高于进程；
  • Java是多线程的编程语言，所以Java在进行并发访问处理的时候可以得到更高的处理性能；

Thread类实现多线程

  • 如果想要在Java之中实现多线程的定义，那么就需要有一个专门的线程主体类进行线程的执行任务的定义，而这个主体类的定义是有要求的，必须实现特定的接口或者继承特定的父类才可以完成；
  • Java里面提供一个java.lang.Thread的程序类，那么一个类只要继承了此类就表示这个类为线程的主体类，但是并不是说这个类就可以直接实现多线程处理了，因为还需要覆写Thread类中提供的一个run()方法（public void run()），而这个方法就属于线程的主方法；
class MyThread extends Thread {     //线程的主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() {     //线程的主体方法
        for (int x = 0; x < 10; x++) {
            System.out.println(this.title + "运行，x = " + x);
        }
    }
}
  • 多线程要执行的功能都应该在run()方法中进行定义，需要说明的是：在正常的情况下如果想要使用一个类中的方法，那么肯定要产生实例化对象，然后去调用类中提供的方法，但是run()方法是不能够直接调用的，因为这里面牵扯到一个操作系统的资源调度问题，所以要想启动多线程必须使用start()方法完成（public void start()）；
//多线程启动
public class ThreadDemo {
    public static void main(String[] args) {
        new MyThread("线程A").start();
        new MyThread("线程B").start();
        new MyThread("线程C").start();
    }
}
  • 通过调用可以发现，虽然调用的是start()方法，但是最终执行的是run()方法，并且所有的线程对象都是交替执行的；
  • 为什么多线程的启动不直接使用run()方法而必须使用Thread类中的start()方法呢？
public synchronized void start() {
    if (threadStatus != 0)    //判断线程的状态
        throw new IllegalThreadStateException();    //抛出了一个异常
    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
        }
    }
}
private native void start0();    //只定义类方法名称但是没有实现
  • 在Java程序执行过程之中考虑到对于不同层次开发者的需求，所以其支持有本地的操作系统函数调用，而这些技术就被称为JNI（Java Native interface）技术，但是Java开发过程之中并不推荐这样使用，利用这项技术可以使用一些操作系统提供底层函数进行一些特殊的处理，而在Thread类里面提供的start0()就表示需要将此方法依赖于不同的操作系统实现；
此图来源于李兴华老师

  • 任何情况下，只要定义了多线程，多线程的启动只有一种方案：Thread类中的start()方法；

  • 发现在start()方法里面会抛出一个“IllegalThreadStateException”异常类对象，但是整个程序并没有使用throws或者是明确的try..catch处理，因为该异常一定是RunimeException的子类，每一个线程类的对象只允许启动一次，如果重复启动则就抛出此类异常；

//重复启动线程
MyThread mt = new MyThread("线程A");
mt.start();
mt.start();    //重复了线程的启动
//Exception in thread "main" java.lang.IllegalThreadStateException

Runnable接口实现多线程

  • 虽然可以通过Thread类的继承来实现多线程的定义，但是在Java里面对于继承永远都是存在有单继承局限的，所以在Java里面又提供有第二种多线程的主体定义结构形式：实现java.lang.Runnable接口；
@FunctionalInterface        //从JDK1.8引入了Lamda表达式之后就变为了函数式接口
public interface Runnable {
    public void run();
}
  • Runnable实现多线程主体类：
class MyThread implements Runnable {     //线程的主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
    @Override
    public void run() {     //线程的主体方法
        for (int x = 0; x < 10; x++) {
        System.out.println(this.title + "运行，x = " + x);
        }
    }
}
  • 此时不再继承Thread父类了，那么对于此时的MyThread类也就不再支持有start()这个继承的方法，如果不使用Thread.start()方法是无法进行多线程启动的，这个时候就需要去观察一下Thread类所提供的构造方法：
    • 构造方法：public Thread(Runnable target);
//启动多线程
class MyThread implements Runnable {     //线程的主体类
    private String title;
    public MyThread(String title) {
        this.title = title;
    }
   @Override
    public void run() {     //线程的主体方法
        for (int x = 0; x < 10; x++) {
            System.out.println(this.title + "运行，x = " + x);
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        Thread threadA = new Thread(new MyThread("线程对象A"));
        Thread threadB = new Thread(new MyThread("线程对象B"));
        Thread threadC = new Thread(new MyThread("线程对象C"));
        threadA.start();
        threadB.start();
        threadC.start();
    }
}
  • 这个时候的多线程实现里面可以发现，由于只是实现了Runnable接口对象，所以此时线程主体类上就不再有单继承的局限了，这样的设计才是一个标准性的设计；
Lamda表达式
public class ThreadDemo {
    public static void main(String[] args) {
        for (int x = 0; x < 3; x++) {
            String title = "线程" + x;
            //写法一
            new Thread(() -> {
                for (int y = 0; y < 10; y ++) {
                    System.out.println(title + "运行，y = " + y);
                }
            }).start();
            //写法二
            Runnable run = () -> {
                for (int y = 0; y < 10; y ++) {
                    System.out.println(title + "运行，y = " + y);
                }
            };
            new Thread(run).start();
        }
    }
}

Thread与Runnable的关系

  • 观察Thread和Runnable的联系：
    • Thread的定义：public class Thread extends Object implements Runnable {}，发现Thread类也是Runnable接口的子类，那么在之前继承Thread类的时候，实际上覆写的还是Runnable接口的run()方法，此时来观察一下程序的类结构：
此图来源于李兴华老师
  • 多线程的设计之中，使用了代理设计模式的结构，用户自定义的线程主体只是负责项目核心功能的实现，而所有的辅助实现全部交由Thread类来处理；
  • 在进行Thread启动多线程的时候调用的是star()方法，而后找到的是run()方法，但通过Thread类的构造方法传递了一个Runnable接口对象的时候，那么该接口对象将Thread类重的target属性所保存，在star()方法执行的时候会调用Thread类中的run()方法，而这个run()方法去调用Runnable接口子类被覆写过的run()方法；
  • 多线程开发的本质实质上是在于多个线程可以进行同一个资源的抢占，那么Thread主要描述的是线程，而资源的描述是通过Runnable完成的；
此图来源于李兴华老师
//利用一个卖票程序来实现多个线程的资源并发访问
package com.company;
class MyThread implements Runnable {     //线程的主体类
    private int ticket = 5;
    @Override
    public void run() {     //线程的主体方法
        for (int x = 0; x < 100; x++) {
            if (this.ticket > 0) {
                System.out.println("卖票，ticket = " + this.ticket--);
            }
        }
    }
}
public class ThreadDemo {
    public static void main(String[] args) {
        MyThread mt = new MyThread();
        new Thread(mt).start();     //第一个线程启动
        new Thread(mt).start();     //第二个线程启动
        new Thread(mt).start();     //第三个线程启动
    }
}
此图来源于李兴华老师

Callable实现多线程

  • 从最传统的开发来讲如果要进行多线程的实现肯定依靠的是Runnable，但是Runnable接口有一个缺点：当线程执行完毕之后无法获取一个返回值，所以从JDK1.5之后就提出了一个新的线程实现接口：java.util.concurrent.Callable接口；
 //观察接口的定义
@FunctionalInterface
public interface Callable<V> {
    public V call() throws Exception;
}
  • 可以发现Callable定义的时候可以设置一个泛型，此泛型的类型就是返回数据的类型，这样一个好处是可以避免向下转型所带来的安全隐患；
此图来源于李兴华老师
//使用Callable实现多线程处理
package com.company;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
class MyThread implements Callable<String> {
    @Override
    public String call() throws Exception {
        for (int x = 0; x < 10; x++) {
            System.out.println("线程执行中,x = " + x);
        }
        return "线程执行完毕";
    }
}
public class ThreadDemo {
    public static void main(String[] args) throws Exception {
        FutureTask<String> task = new FutureTask<String>(new MyThread());
        new Thread(task).start();
        System.out.println("线程返回数据" + task.get());
    }
}
  • Runnable与Callable的区别：
    • Runnable是在JDK1.0的时候提出的多线程的实现接口，而Callable是在JDK1.5之后提出的；
    • java.lang.Runnable接口之中只提供有一个run()方法，并且没有返回值；
    • java.util.concurrent.Callable接口提供有call方法，可以有返回值；

多线程运行状态

  • 对于多线程开发来言，编写程序的过程之中总是按照：定义线程主体类，而后通过Thread类进行线程的启动，并不意味着你调用start()方法，线程就已经开始运行了，因为整体的线程处理有自己的一套运行的状态；
此图来源于李兴华老师
  • 任何一个线程的对象都应该使用Thread类进行封装，所以线程的启动使用的是start()，但是启动的时候实际上若干个线程都将进入到一种就绪状态，现在并没有执行；
  • 进入到就绪状态之后，就需要等待进行资源调度，当某一个线程调度成功之后则进入到运行状态（run()方法），但是所有的线程不可能一致持续的执行下去，中间需要产生一些暂停的状态，例如：某个线程执行一段时间之后就需要让出资源，而后这个线程就将进入到阻塞状态，随后重新回归到就绪状态；
  • 当run()方法执行完毕之后，实际上该线程的主要任务也就结束了，那么此时就可以直接进入到停止状态；
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
平台声明：文章内容（如有图片或视频亦包括在内）由作者上传并发布，文章内容仅代表作者本人观点，简书系信息发布平台，仅提供信息存储服务。

推荐阅读更多精彩内容