多线程实现方式——Java多线程（1）

青旅半醒 2023-02-14 01:48 32阅读 0赞

##### 1. 1继承Thread并重写run方法： #####

public class ThreadDemo1 extends Thread { 
    
        public ThreadDemo1(){ 
        }
        public ThreadDemo1(String name){ 
            super(name);
        }
        public void run(){ 
            for(int i = 0;i<10;i++){ 
                System.out.println("当前线程名称："+ Thread.currentThread().toString()+"-"+i);
            }
        }
    }
    
    public class Client { 
        public static void main(String[] args) { 
            ThreadDemo1 thread = new ThreadDemo1("子线程");
            //开启子线程
            thread.start();
            for (int i = 0;i<10;i++){ 
                System.out.println("当前的线程名称是："+Thread.currentThread().toString()+"-"+i);
            }
        }
    }

在执行到thread.start()方法时，jvm开启一个子线程，主线程在main方法执行时被创建，这样一个最简单的多线程就实现了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70]

当线程的任务执行结束之后，java虚拟机栈内存自动释放

##### 1.2 使用Runnable接口 #####

步骤：

*  定义Runable接口的实现类，并实现run实现类，
 *  创建该实现类的实例
 *  调用start()方法

public class RunnableImpl implements Runnable { 
        @Override
        public void run() { 
            try { 
                System.out.println("子线程："+ Thread.currentThread().toString()+"休眠1秒钟");
                Thread.sleep(1000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }
    
    public class Client1 { 
            public static void main(String[] args) { 
                RunnableImpl runnable = new RunnableImpl();
                //创建线程对象
                Thread thread = new Thread(runnable);
                thread.start();
                for (int i = 0;i<10;i++){ 
                    System.out.println("当前的线程名称是："+Thread.currentThread().toString()+"-"+i);
                }
            }
        }

通过实现Runnable接口，使得该类有了多线程类的特征。不管是继承Thread类还是实现 Runnable接口来实现多线程，最终还是通过Thread的对象的API来控制线程的

##### 1.3 使用匿名内部类实现多线程 #####

/** * 使用匿名内部类的方式实现多线程 */
    public class AnonymThread { 
        public static void main(String[] args) { 
            new Thread(new Runnable() { 
                @Override
                public void run() { 
                        System.out.println("子线程"+Thread.currentThread().toString()+"执行了");
                }
            }).start();
            System.out.println("主线程"+Thread.currentThread().toString()+"执行了");
        }
    }

那在内存中又是如何执行的呢？如果不了解jvm内存模型请移步[添加链接描述][Link 1]  
每个线程都会有一个私有的虚拟机栈，进行方法的压栈和出栈  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 1]

##### 1.4 使用Thread和是用Runnable实现多线程的区别 #####

根本原因：Java是不支持多继承的，但是支持实现多个接口，如果继承Thread则不利于资源的共享  
因此Runnable接口相较于Thread优势更大：

*  适合多个相同的程序代码的线程去共享同一个资源。
 *  可以避免java中的单继承的局限性。
 *  增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立。
 *  线程池只能放入实现Runable或Callable类线程，不能直接放入继承Thread的类。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200530171015369.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz,size_16,color_FFFFFF,t_70
[Link 1]: https://blog.csdn.net/gwz_6903
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200530172655814.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2d3el82OTAz,size_16,color_FFFFFF,t_70