您的位置: 首页  >  文章  >  多线程的那点事一--线程的实现、生命周期、操作方法和优先级

多线程的那点事一--线程的实现、生命周期、操作方法和优先级

分类: 文章 • 2025-02-23 19:57:16

实现多线程的两种方式：

java中主要提供两种方式实现线程：分别为继承Thead类和实现Runnable接口。

1．  通过继承Thread类，重写Thread的run()方法，将线程运行的逻辑放在其中

2．  通过实现Runnable接口，实例化Thread类

一、通过继承Thread类实现多线程

class MyThread extends Thread{
    String name = null;
    int ticket = 0;
    public MyThread(String name){
        this.name = name;
    }
    public synchronized void run(){
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+this.name+" ticket:"+ticket++);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }          
        }
 
    }
}

 

public static void main(String[] args) {
        
        MyThread mThread1 = new MyThread("线程一");
        MyThread mThread2 = new MyThread("线程二");
        MyThread mThread3 = new MyThread("线程三");
        mThread1.start();
        mThread2.start();
        mThread3.start();
    }

运行结果如下：

Thread-1线程二 ticket:0
Thread-0线程一 ticket:0
Thread-2线程三 ticket:0
Thread-1线程二 ticket:1
Thread-0线程一 ticket:1
Thread-2线程三 ticket:1
Thread-1线程二 ticket:2
Thread-2线程三 ticket:2
Thread-0线程一 ticket:2
Thread-1线程二 ticket:3
Thread-2线程三 ticket:3
Thread-0线程一 ticket:3
Thread-1线程二 ticket:4
Thread-2线程三 ticket:4
Thread-0线程一 ticket:4

二、通过继承Runnable接口实现多线程

class RunThread implements Runnable{

    int Counter = 0;
    @Override
    public synchronized void run() {
        for(int i=0;i<5;i++){
            System.out.println(Thread.currentThread().getName()+"count:"+Counter++);
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }            
        }
    }    
}
public static void main(String[] args) {
        
        RunThread rThread = new RunThread();
        Thread t1 = new Thread(rThread,"线程一");
        Thread t2 = new Thread(rThread,"线程二");
        Thread t3 = new Thread(rThread,"线程三");
        t1.start();
        t2.start();
        t3.start();
　　}

输出结果：

线程一count:0
线程一count:1
线程一count:2
线程一count:3
线程一count:4
线程二count:5
线程二count:6
线程二count:7
线程二count:8
线程二count:9
线程三count:10
线程三count:11
线程三count:12
线程三count:13
线程三count:14

线程的生命周期：

线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。

多线程的那点事一--线程的实现、生命周期、操作方法和优先级

 

下面对线程生命周期中的 7 种状态做说明。

  1. 出生状态：用户在创建线程时所处的状态，在用户使用该线程实例调用 start() 方法之前，线程都处于出生状态。
  2. 就绪状态：也称可执行状态，当用户调用 start() 方法之后，线程处于就绪状态。
  3. 运行状态：当线程得到系统资源后进入运行状态。
  4. 等待状态：当处于运行状态下的线程调用 Thread 类的 wait() 方法时，该线程就会进入等待状态。进入等待状态的线程必须调用 Thread 类的 notify() 方法才能被唤醒。notifyAll() 方法是将所有处于等待状态下的线程唤醒。
  5. 休眠状态：当线程调用 Thread 类中的 sleep() 方法时，则会进入休眠状态。
  6. 阻塞状态：如果一个线程在运行状态下发出输入/输出请求，该线程将进入阻塞状态，在其等待输入/输出结束时，线程进入就绪状态。对阻塞的线程来说，即使系统资源关闭，线程依然不能回到运行状态。
  7. 死亡状态：当线程的 run() 方法执行完毕，线程进入死亡状态。

根据图 1 所示，可以总结出使线程处于就绪状态有如下几种方法。

  • 调用 sleep() 方法。
  • 调用 wait() 方法。
  • 等待输入和输出完成。

当线程处于就绪状态后，可以用如下几种方法使线程再次进入运行状态。

  • 线程调用 notify() 方法。
  • 线程调用 notifyAll() 方法。
  • 线程调用 intermpt() 方法。
  • 线程的休眠时间结束。
  • 输入或者输出结束。

操作线程的方法：

一种能控制线程行为的方法是调用sleep()方法，sleep方法需要一个参数用于指定该线程休眠的时间，该时间以毫秒为单位。

sleep语法：

package Thread1;
class MyThread implements Runnable{    // 实现Runnable接口
    public void run(){    // 覆写run()方法
        for(int i=0;i<50;i++){
            try{
                    Thread.sleep(500) ;    // 线程休眠
            }catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;    // 取得当前线程的名字
        }
    }
};
public class demo1{
    public static void main(String args[]){
        MyThread mt = new MyThread() ;    // 实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");        // 实例化Thread对象
        t.start() ;    // 启动线程
    }
};

线程的加入：

package Thread1;
class MyThread implements Runnable{    // 实现Runnable接口
    public void run(){    // 覆写run()方法
        for(int i=0;i<50;i++){
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;    // 取得当前线程的名字
        }
    }
};
public class demo1{
    public static void main(String args[]){
        MyThread mt = new MyThread() ;    // 实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");        // 实例化Thread对象
        t.start() ;    // 启动线程
        for(int i=0;i<50;i++){
            if(i>10){
                try{
                    t.join() ;    // 线程强制运行
                }catch(InterruptedException e){}
            }
            System.out.println("Main线程运行 --> " + i) ;
        }
    }
};

当某个线程使用join()方法加入到另外一个线程时，另一个线程会等待该线程执行结束后继续执行。

线程的中断：

一个线程可以被另一个线程中断其操作的状态，使用 interrupt（）方法完成。

package Thread1;
class MyThread implements Runnable{    // 实现Runnable接口
    public void run(){    // 覆写run()方法
        System.out.println("1、进入run()方法") ;
        try{
                Thread.sleep(10000) ;    // 线程休眠10秒
                System.out.println("2、已经完成了休眠") ;
        }catch(InterruptedException e){
            System.out.println("3、休眠被终止") ;
            return ; // 返回调用处
        }
        System.out.println("4、run()方法正常结束") ;
    }
};
public class demo1{
    public static void main(String args[]){
        MyThread mt = new MyThread() ;    // 实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");        // 实例化Thread对象
        t.start() ;    // 启动线程
        try{
                Thread.sleep(2000) ;    // 线程休眠2秒
        }catch(InterruptedException e){
            System.out.println("3、休眠被终止") ;
        }
        t.interrupt() ;    // 中断线程执行
    }
};

多线程的那点事一--线程的实现、生命周期、操作方法和优先级

线程的优先级：

优先级分为最低，最高，普通三个（Thread.MIN_PRIORITY，Thread.MAX_PRIORITY，Thread.NORM_PRIORITY），

package Thread1;
class MyThread implements Runnable{    // 实现Runnable接口
    public void run(){    // 覆写run()方法
        for(int i=0;i<5;i++){
            try{
                    Thread.sleep(500) ;    // 线程休眠
            }catch(InterruptedException e){}
            System.out.println(Thread.currentThread().getName()
                    + "运行，i = " + i) ;    // 取得当前线程的名字
        }
    }
};
public class demo1{
    public static void main(String args[]){
        Thread t1 = new Thread(new MyThread(),"线程A") ;    // 实例化线程对象
        Thread t2 = new Thread(new MyThread(),"线程B") ;    // 实例化线程对象
        Thread t3 = new Thread(new MyThread(),"线程C") ;    // 实例化线程对象
        t1.setPriority(Thread.MIN_PRIORITY) ;    // 优先级最低
        t2.setPriority(Thread.MAX_PRIORITY) ;    // 优先级最低
        t3.setPriority(Thread.NORM_PRIORITY) ;    // 优先级最低
        t1.start() ;    // 启动线程
        t2.start() ;    // 启动线程
        t3.start() ;    // 启动线程
    }
};

运行结果：

线程B运行，i = 0
线程C运行，i = 0
线程A运行，i = 0
线程B运行，i = 1
线程C运行，i = 1
线程A运行，i = 1
线程B运行，i = 2
线程A运行，i = 2
线程C运行，i = 2
线程B运行，i = 3
线程C运行，i = 3
线程A运行，i = 3
线程B运行，i = 4
线程C运行，i = 4
线程A运行，i = 4

 

 

 

 

 

 

 

 

 

 

相关推荐