1.7线程实现方式

最新推荐文章于 2025-05-04 09:52:00 发布

原创最新推荐文章于 2025-05-04 09:52:00 发布 · 212 阅读

0 ·

CC 4.0 BY-SA版权

java基础专栏收录该内容

34 篇文章

订阅专栏

本文详细介绍Java中创建和管理线程的多种方法，包括通过继承Thread类、实现Runnable接口及使用匿名内部类。探讨了线程与进程的区别，线程调度机制，以及并发与并行的概念。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Thread类

创建线程方式一

定义一个Thread的子类
重写run方法
创建Thread的子类对象
调用start方法，开启新线程，执行run方法

//自定义线程类
 public class MyThread extends Thread{ 
      public MyThread(String name){      
                 super(name);         
       }     
        /* * 重写run方法      
          *  定义线程要执行的代码      
          *  */     
        public void run(){            
            for (int i = 0; i < 20; i++) {
                 System.out.println(getName()+i);             
               }          
          }     
  }  
//测试类
public class Demo {     
      public static void main(String[] args) {        
           System.out.println("这里是main线程");         
           MyThread mt = new MyThread("小强");                   
           mt.start();//开启了一个新的线程           
           for (int i = 0; i < 20; i++) {      
                  System.out.println("旺财:"+i);              
             }          
         }      
  }

构造方法

public Thread():分配一个新的线程对象。
public Thread(String name) :分配一个指定名字的新的线程对象。
public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
public Thread(Runnable target,String name):分配一个带有指定目标新的线程对象并指定名字。

常用方法

public String getName() :获取当前线程名称。
public static Thread currentThread() :返回对当前正在执行的线程对象的引用。
public void setName(String name):改变线程名称，使之与参数name相同；（也可以使用构造方法设置线程名称）
public static void sleep(long millis) :使当前正在执行的线程以指定的毫秒数暂停（暂时停止执行）。

创建线程的第二种方式

采用java.lang.Runnable 也是非常常见的一种，我们只需要重写run方法即可。
步骤如下：

定义Runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。
调用线程对象的start()方法来启动线程。

public class MyRunnable implements Runnable
{ 
    @Override      
    public void run() {      
        for (int i = 0; i < 20; i++) {          
             System.out.println(Thread.currentThread().getName()+" "+i);              
         }          
      }   
 }
 
public class Demo {     
    public static void main(String[] args) {         
           //创建自定义类对象  线程任务对象         
           MyRunnable mr = new MyRunnable();         
           //创建线程对象         
           Thread t = new Thread(mr, "小强");         
           t.start();         
           for (int i = 0; i < 20; i++) {             
                System.out.println("旺财 " + i);         
            }     
       } 
}

Thread 和 Runnable的区别

避免了单继承的局限性
一个类只能继承一个类，类继承了Thread类就不能继承其他的类
而实现了Runnable接口，还可以继承其他的类，实现其他的接口
增强了程序的扩展性，降低了程序的耦合性(解耦)
实现Runnable接口的方式，把设置线程任务和开启新线程进行了分离（解耦）

匿名内部类方式实现多线程创建

public class ThreadTest {
    public static void main(String[] args) {
        //第一种匿名方式：线程的父类是Thread
        new Thread(){
            @Override
            public void run() { 
                System.out.println("hello world");
            }
        }.start();

        //第二种匿名方式：实现Runnable接口
        Runnable r=new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        new Thread(r).start();

        //第三种方式：简化接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        }).start();
    }
}