Java实现多线程的区别

约定不等于承诺〃 2023-06-06 10:49 12阅读 0赞

**Java中为什么要单继承，多实现，总结如下:**

若为多继承，那么当多个父类中有重复的属性或者方法时，子类的调用结果会含糊不清，因此用了单继承。

为什么是多实现呢？

通过实现接口拓展了类的功能，若实现的多个接口中有重复的方法也没关系，因为实现类中必须重写接口中的方法，所以调用时还是调用的实现类中重写的方法。那么各个接口中重复的变量又是怎么回事呢？

接口中，所有属性都是 static final修饰的，即常量，这个什么意思呢，由于JVM的底层机制，所有static final修饰的变量都在编译时期确定了其值，若在使用时，两个相同的常量值不同，在编译时期就不能通过。

**Java实现多线程的方式**  
1.extends Thread  
2.implements Runnable  
3.implements Callable <?>  
有返回值 配合Future和FutureTask配合使用

首先一定要明确的是，使用我们的Runnable接口与Thread类相比，解决了单继承的定义局限，所以在优先级上已经确定使用Runnable接口。  
首先看jdk源码中Thread类定义:

public class Thread extends Object implements Runnable

发现Thread类实现了Runnable接口，那么这样一来就变为了以下形式。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzIzMDA2Mw_size_16_color_FFFFFF_t_70]  
我们可以看出，Runnable接口实现多线程其实很像代理模式的应用。很好的起到了设计模式中原则中的迪米特原则。之所以是"像",因为如果是代理设计模式，那么客户端调用的应该是接口里面提供的run()方法。

除了以上联系之外，使用Runnable接口可以比Thread类更好的描述出数据共享这一个概念，此时的数据共享指的是多个线程访问同一资源的操作。  
范例:观察代码(每一个线程对象都必须通过start()启动)

package TestDemo;
    
    
    
    class MyThread extends Thread{
        private int ticket=10;//这里的变量会压入局部变量表 因为并没有用static声明
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if(this.ticket>0){
                    System.out.println("sell,ticket="+this.ticket--);
                }
            }
        }
    }
    
    public class TestDemo{
        
        public static void main(String[] args) {
            MyThread thread1=new MyThread();
            MyThread thread2=new MyThread();
            MyThread thread3=new MyThread();
    
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }

![在这里插入图片描述][20191011114802790.png]  
**结果三个thread类都在卖各自的10张票，这是由于我们并没有给ticket设置为static变量，所以这个数据没有被录入元数据区，而被压入了局部变量表，在执行实例化操作后，各自生成了一块堆内存指向，此时并不存在数据共享这一概念。  
在JVM内存模型基础上，我们可以看这张基于多线程的内存模型。**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzIzMDA2Mw_size_16_color_FFFFFF_t_70 1]也很好的诠释了这一点。而Runnable就完美实现了这张内存模型图，我们可以把主存看作是MyThread类中的元数据，三个new Thread类匿名内部类对象实例看作3块工作内存。  
范例:利用Runnable实现。

package TestDemo;
    
    
    
    class MyThread implements Runnable{
        private int ticket=10;//这里的变量会压入局部变量表 因为并没有用static声明
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                if(this.ticket>0){
                    System.out.println("sell,ticket="+this.ticket--);
                }
            }
        }
    }
    
    public class TestDemo{
        
        public static void main(String[] args) {
            MyThread mt=new MyThread();
            new Thread(mt).start();
            new Thread(mt).start();
            new Thread(mt).start();
        
        }
    }

![在这里插入图片描述][20191011114918857.png]  
**原理分析:这是由于三个不同的栈都指向了同一块堆内存对象，确保了他们操作的是同一个实例化对象。**

因而当多个线程访问同一资源时候，我们使用Runnable更好的描述了数据共享这个概念(本质上是JVM虚拟栈是否指向同一块堆内存)

**总结:请解释Thread类与Runnable接口实现多线程的区别(请解释多线程两种实现方式区别)?**  
Thread类是Runnable接口的子类，使用Runnable接口实现多线程可以避免单继承的局限性。  
Runnable接口实现的多线程可以比Thread类实现的多线程更加清楚的描述数据共享的概念(本质上是JVM虚拟栈是否指向同一块堆内存)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzIzMDA2Mw_size_16_color_FFFFFF_t_70]: /images/20230601/6fac759bc8e94854926323b18e4a35a9.png
[20191011114802790.png]: /images/20230601/d81a1fd363f84fc09493b7613ad9273f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzIzMDA2Mw_size_16_color_FFFFFF_t_70 1]: /images/20230601/2be41631722f4156b24cab4d30c79716.png
[20191011114918857.png]: /images/20230601/0a90009e6eac4815a8a97bfac77b70e0.png