Java-多线程-两种实现方法、优先级

一、基本概念

  1. 进程是程序的一次动态执行过程,经历代码加载、执行、执行完毕的完整过程。
  2. 多线程是实现并发机制的一种有效手段,进程和线程都是实现并发的一个基本单位。
  3. 所有的线程依附于进程才能存在。

二、两种多线程实现方式及区别

Java中如果要实现多线程程序,必须依靠一个线程的主体类。这个线程的主体类在定义的时候可以继承Thread类,或者实现Runnable接口来完成。

继承Thread类实现多线程

  1. java.lang.Thread类负责线程操作,线程启动的主方法需要覆写Thread类中的run()方法。
  2. 再在主方法中通过Thread类的start()来启动线程,线程启动后会默认调用run()方法。
package com.joeaaa.demo12;
/*
* 使用Thread类实现多线程,start
*/

class MyThread extends Thread{ // 线程的主体类
    private String title;
    public MyThread(String title){
        this.title = title;
    }

    @Override
    public void run() { // 线程的主方法
        super.run();
        for(int x = 0; x<20; x++){
            System.out.println(this.title + " Running on "+ x);
        }
    }
}

public class MyThreadTest {
    public static void main(String[] args) {
        MyThread thread1 = new MyThread("线程A");
        MyThread thread2 = new MyThread("线程B");
        MyThread thread3 = new MyThread("线程C");
        thread1.start();
        thread2.start();
        thread3.start();
    }
}
 线程A Running on 0
 线程A Running on 1
 线程A Running on 2
 线程A Running on 3
 线程A Running on 4
 线程A Running on 5
 线程A Running on 6
 线程A Running on 7
 线程B Running on 0
 线程B Running on 1
 线程B Running on 2
 线程B Running on 3
 线程B Running on 4
 线程B Running on 5
 线程B Running on 6
 线程B Running on 7
 线程B Running on 8
 线程B Running on 9
 线程B Running on 10
 线程B Running on 11
 线程B Running on 12
 线程B Running on 13
 线程B Running on 14
 线程B Running on 15
 线程B Running on 16
 线程B Running on 17
 线程B Running on 18
 线程B Running on 19
 线程A Running on 8
 线程A Running on 9
 线程A Running on 10
 线程A Running on 11
 线程A Running on 12
 线程A Running on 13
 线程A Running on 14
 线程A Running on 15
 线程A Running on 16
 线程C Running on 0
 线程C Running on 1
 线程C Running on 2
 线程C Running on 3
 线程C Running on 4
 线程C Running on 5
 线程C Running on 6
 线程C Running on 7
 线程C Running on 8
 线程C Running on 9
 线程C Running on 10
 线程C Running on 11
 线程C Running on 12
 线程C Running on 13
 线程C Running on 14
 线程C Running on 15
 线程C Running on 16
 线程C Running on 17
 线程C Running on 18
 线程C Running on 19
 线程A Running on 17
 线程A Running on 18
 线程A Running on 19
 Process finished with exit code 0

实现Runnable接口实现多线程

使用Runnable接口实现,可以避免单继承的局限性。

  1. 定义线程主体类 implements Runnable接口
  2. 通过Thread类中的构造方法 public Thread(Runnable target)来接收Runnable接口对象。
package com.joeaaa.demo12;
/*
 * 实现Runnable接口实现多线程
 */

class MyRunnable implements Runnable{ // 线程的主体类
    private String title;
    public MyRunnable(String title){
        this.title = title;
    }

    @Override
    public void run() { // 线程的主方法
        for(int x = 0; x<20; x++){
            System.out.println(this.title + " Running on "+ x);
        }
    }
}

public class MyRunnableTest {
    public static void main(String[] args) {
        MyRunnable thread1 = new MyRunnable("线程A");
        MyRunnable thread2 = new MyRunnable("线程B");
        MyRunnable thread3 = new MyRunnable("线程C");
        new Thread(thread1).start();
        new Thread(thread2).start();
        new Thread(thread3).start();
    }
}

Thread类与Runnable接口实现多线程的区别

  1. 多线程的两种实现方式都需要一个线程的主类,而这个类可以实现Runnable接口或者继承Thread类,两种方法都需要在子类中覆写run()方法,此方法为线程的主方法;
  2. Thread类是Runnable接口的子类,而且使用Runnable接口可以避免单继承局限,可更加方便的实现数据共享的概念。
class MyThread extends Thread{ // 线程的主体类
    private int ticket = 5; // 一共五张票
    @Override
    public void run() { // 线程的主方法
        // 线程操作方法
    }
}

// 启动方式
MyThread mt = new Mythread();
mt.start();
class MyThread implements Runnable{ // 线程的主体类
    private int ticket = 5; // 一共五张票
    @Override
    public void run() { // 线程的主方法
        // 线程操作方法
    }
}
// 启动方式
MyThread mt = new Mythread();
new Thread(mt).start();

三、线程的主要操作方法

线程名称

由于线程的运行状态是不能预见的,操作线程需要线程名称。每次操作的都是正在执行run()方法的线程。

  1. 构造方法:public Thread(Runnable target, String name);
  2. 设置名称:public final void setName(String name);
  3. 取得名称:public final String getName();
  4. 取得当前线程:public static Thread currentThread();
package com.joeaaa.demo12;

/*
* 为线程命名
*/
class MyThread0 implements Runnable{ // 线程的主体类
    @Override
    public void run() { // 线程的主方法
        System.out.println(Thread.currentThread().getName());
    }
}
public class GetThreadNameTest {
    public static void main(String[] args) {
        MyThread0 mt = new MyThread0();
        new Thread(mt).start(); // Thread-0
        new Thread(mt).start(); // Thread-1
        new Thread(mt,"线程A").start(); // 线程A
        new Thread(mt,"线程B").start(); // 线程B
        mt.run() // main  主方法中,类的run()方法
    }
}
  • 线程的休眠:Thread.sleep(1000),休眠1s;

线程的优先级

优先级越高,越有可能先执行

  1. 设置线程的优先级:public final void setPriority(int newPriority);
  2. 取得线程的优先级:public final int getPriority();
  3. 最高优先级:public static final int MAX_PRIORITY, 10;
  4. 中等优先级:public static final int NORM_PRIORITY, 5;
  5. 最低优先级:public static final int MIN_PRIORITY, 1;

主线程的优先级是中等级别,5。