Java基础学习总结 -- 多线程的实现

2023-08-11 17:26:46

　　继承Thread类
　　start()方法实现多线程的原理
　　实现Runnable接口
　　Thread类与 Runnable接口的联系与区别

　　多线程的实现方法：

　　　　继承Thread类

　　　　实现Runnable接口

　　-------------------------------------------------------------------------------------

　　1. 继承Thread类

　　　　继承Thread类之后，需要覆盖父类的 public void run() 方法，作为线程的主方法。

　　　　所有线程的执行一定是并发的，即：同一个时间段上会有多个线程交替执行。为了达到这样的目的，绝对不能直接调用run()方法，而是应该调用Thread类的start()方法启动多线程。

　　　　调用 start() 方法和调用 run() 方法的对比：

public class MyThread extends Thread {

    private String name;

    public MyThread(String name) {

        this.name = name;

    }

    @Override

    public void run() {

        for(int i=0; i<10; i++) {

        System.out.println(name + "打印：" + i);

        }

    }

    public static void main(String[] args) {

        MyThread mt1 = new MyThread("线程A");

        MyThread mt2 = new MyThread("线程B");

        MyThread mt3 = new MyThread("线程C");

        mt1.start();

        mt2.start();

        mt3.start();

    }

}

　　运行结果：（三个线程同时且交替执行，没有固定的执行顺序）

public class MyThread extends Thread {

    private String name;

    public MyThread(String name) {

        this.name = name;

    }

    @Override

    public void run() {

        for(int i=0; i<5; i++) {

        System.out.println(name + "打印：" + i);

        }

    }

    public static void main(String[] args) {

        MyThread mt1 = new MyThread("线程A");

        MyThread mt2 = new MyThread("线程B");

        MyThread mt3 = new MyThread("线程C");

        mt1.run();

        mt2.run();

        mt3.run();

    }

}

　　运行结果：（三个程序依次顺序执行）

　　2. start()方法实现多线程的原理

　　　　打开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();

　　　　native关键字是指调用操作系统的方法，start0()方法是所在操作系统的方法。

　　　　由于线程的启动需要牵扯到操作系统中资源的分配问题，所以具体的线程的启动应该根据不同的操作系统有不同的实现。而JVM根据不同的操作系统中定义的start0()方法进行不同的实现。这样，在多线程的层次上start0()方法的名称不改变，而不同的操作系统有不同的实现。

原理图

　　　　结论：只有Thread类的start()方法才能进行操作系统资源的分配，所以启动多线程的方式永远就是Thread类的start()方法。

　　3. 实现Runnable接口

　　　　一般使用这种方式来实现多线程，因为这样可以避免继承Thread类的单继承局限。

package test;

public class MyThread implements Runnable {

    private String name;

    public MyThread(String name) {

        this.name = name;

    }

    @Override

    public void run() {

        for(int i=0; i<5; i++) {

        System.out.println(name + "打印：" + i);

        }

    }

    public static void main(String[] args) {

        MyThread mt1 = new MyThread("线程A");

        MyThread mt2 = new MyThread("线程B");

        MyThread mt3 = new MyThread("线程C");

        new Thread(mt1).start();

        new Thread(mt2).start();

        new Thread(mt3).start();

    }

}

　　4. Thread类与 Runnable接口的联系与区别

　　　　联系：

　　　　　　Thread类是实现了Runnable接口的类。

　　　　区别：

　　　　　　Runnable接口实现的多线程要比Thread类实现的多线程更方便的表示出数据共享的概念。

　　　　　　范例：希望有三个线程进行卖票

//使用Thread类实现

public class MyThread extends Thread {

    private String name;

    int tickets = 5;

    public MyThread(String name) {

        this.name = name;

    }

    @Override

    public void run() {

        while(tickets>0) {

            System.out.println(name + "买票出一张票，剩余票数：" + (--tickets));

        }

    }

    public static void main(String[] args) {

        MyThread mt1 = new MyThread("线程A");

        MyThread mt2 = new MyThread("线程B");

        MyThread mt3 = new MyThread("线程C");

        mt1.start();

        mt2.start();

        mt3.start();

    }

}

/*

线程C买票出一张票，剩余票数：4

线程A买票出一张票，剩余票数：4

线程B买票出一张票，剩余票数：4

线程A买票出一张票，剩余票数：3

线程C买票出一张票，剩余票数：3

线程A买票出一张票，剩余票数：2

线程B买票出一张票，剩余票数：3

线程A买票出一张票，剩余票数：1

线程C买票出一张票，剩余票数：2

线程C买票出一张票，剩余票数：1

线程A买票出一张票，剩余票数：0

线程B买票出一张票，剩余票数：2

线程B买票出一张票，剩余票数：1

线程B买票出一张票，剩余票数：0

线程C买票出一张票，剩余票数：0

*/

//使用Runnable接口实现

public class MyThread implements Runnable {

    int tickets = 5;

    @Override

    public void run() {

        while(tickets>0) {

            System.out.println(Thread.currentThread().getName() + "买票出一张票，剩余票数：" + (--tickets));

        }

    }

    public static void main(String[] args) {

        MyThread mt = new MyThread();

        new Thread(mt,"线程A").start();

        new Thread(mt,"线程B").start();

        new Thread(mt,"线程C").start();

    }

}

/*

线程B买票出一张票，剩余票数：3

线程A买票出一张票，剩余票数：4

线程C买票出一张票，剩余票数：2

线程A买票出一张票，剩余票数：0

线程B买票出一张票，剩余票数：1

*/

//同一个线程不能重复启动，否则会出现异常

public class MyThread extends Thread {

    int tickets = 5;

    @Override

    public void run() {

        while(tickets>0) {

            System.out.println("买票出一张票，剩余票数：" + (--tickets));

        }

    }

    public static void main(String[] args) {

        MyThread mt = new MyThread();

        mt.start();

        mt.start();

        mt.start();

    }

}

/*

Exception in thread "main" 买票出一张票，剩余票数：4

买票出一张票，剩余票数：3

买票出一张票，剩余票数：2

买票出一张票，剩余票数：1

买票出一张票，剩余票数：0

java.lang.IllegalThreadStateException

    at java.lang.Thread.start(Unknown Source)

    at test.MyThread.main(MyThread.java:17)

*/

　　　　图释：

使用Thread类的内存情况

使用Runnable接口的内存情况

　　面试题：请解释多线程的两种实现方式以及区别，并用代码验证？

　　　　答：多线程需要一个线程的主类，这个类要么继承Thread类，要么实现Runnable接口；

　　　　　　使用Runnable接口要比Thread类更好地实现数据共享的操作，并且使用Runnable接口可以避免单继承局限。

　　　　　　代码如上。

码农公寓

相关文章