方式一:继承Thread类

一、步骤

  1. 创建一个继承于Thread类的子类
  2. 重写Thread类run() -->将此线程执行的操作声明在run()
  3. 创建Thread类的子类对象
  4. 通过此对象调用start()
//1.创建一个继承于Thread类的子类
class MyThread extends Thread {
    //2.重写Thread类的run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start():①启动当前线程 ②调用当前线程的run()
        t1.start();
    //注意1:不能通过直接调用run()的方式启动线程
    //注意2:启动第二个线程时,需要重新创建一个线程对象
    
    //注意3:创建Thread类的匿名子类的方式
    new Thread(){
        @Override
        ......
    }.start();

    }
}

二、测试Thread中的常用方法

  1. start():启动当前线程,调用当前线程的run()
  2. run():通常需要重写Thread类中的此方法,将创建的线程要执行的操作声明在此方法中
  3. currentThread():静态方法,返回执行当前代码的线程
  4. getName():获取当前线程的名字Thread.currentThread().getName()
  5. setName():设置当前线程的名字t1.setName("线程一")其中给主线程命名方式为Thread.currentThread().setName("主线程")
  6. yield():释放当前cpu的执行权
if(i % 20 == 0){
    yield();//当某个线程执行到此处时直接释放,被另一个线程执行
    //this.yield();
}
  1. join():在线程a中调用线程b的join(),此时线程a就进入阻塞状态,知道线程b完全执行完以后,线程a才结束阻塞状态t1.join();//需要抛异常
  2. stop():已过时。当执行此方法时,强制结束当前线程
  3. sleep(long millitime):让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内,当前线程时阻塞状态sleep(500);//需要抛异常
  4. isAlive():判断当前线程是否存活t1.isAlive();

三、线程的优先级

1.线程的优先级等级

  • MAX_PRIORITY:10
  • MIN_PRIORITY:1
  • NORM_PRIORITY:5

2.涉及的方法

  • getPriority() :返回线程优先值getPriority()
  • setPriority(int newPriority) :改变线程的优先级
t1.setPriority(Thread.MAX_PRIORITY);
// t1.setPriority(Thread.MIN_PRIORITY);
//t1.setPriority(6);
说明
  • 线程创建时继承父线程的优先级
  • 低优先级只是获得调度的概率低,并非一定是在高优先级线程之后才被调用

方式二:实现Runnable接口

步骤

  1. 创建一个实现了Runnable接口的类
  2. 实现类去实现Runnable中的抽象方法run()
  3. 创建实现类的对象
  4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
  5. 通过Thread类的对象调用start()
//1. 创建一个实现了Runnable接口的类
class MThread implements Runnable{
    //实现类去实现Runnable中的抽象方法run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest2 {
    public static void main(String[] args) {
        //3. 创建实现类的对象
        MThread mThread = new MThread();
        //4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
        Thread t1 = new Thread(mThread);
        //5. 通过Thread类的对象调用start()
        t1.start();
    }
}

比较以上两种创建线程的方式

优先选择实现Runnable接口的方式

原因
  1. 实现的方式没有类的单继承性的局限性
  2. 实现的方式更适合来处理多个线程有共享数据的情况(继承的方式有共享数据需要static修饰唯一性)
联系

public class Thread implements Runnable

相同点

两种方式都需要重写run(),将线程要执行的逻辑声明在run()

方式三:实现Callable接口

步骤

  1. 创建一个实现Callable的实现类
  2. 实现call方法,将此线程需要执行的操作声明在call()
  3. 创建Callable接口实现类的对象
  4. 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中,创建FutureTask的对象
  5. FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
  6. 获取Callablecall方法的返回值(根据实际需求选择)
//1. 创建一个实现Callable的实现类
class NumThread implements Callable{
    //2. 实现call方法,将此线程需要执行的操作声明在call()中
    @Override
    public Object call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if(i % 2 == 0){
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}
public class ThreadNew {
    public static void main(String[] args) {
        //3. 创建Callable接口实现类的对象
        NumThread numThread = new NumThread();
        //4. 将此Callable接口实现类的对象作为参数传递到FutureTask构造器中,创建FutureTask的对象
        FutureTask futureTask = new FutureTask(numThread);
        //5. 将FutureTask的对象作为参数传递到Thread类的构造器中,创建Thread对象,并调用start()
        new Thread(futureTask).start();
        try {
            //6. 获取Callable中call方法的返回值(根据实际需求选择)
            //get()返回值即为FutureTask构造器参数Callable实现类重写的Call()的返回值
            Object sum = futureTask.get();
            System.out.println("get返回值" + sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

1.与使用Runnable相比, Callable功能更强大些

  • 相比run()方法,可以有返回值
  • 方法可以抛出异常
  • 支持泛型的返回值
  • 需要借助FutureTask类,比如获取返回结果

2.Future接口

  • 可以对具体RunnableCallable任务的执行结果进行取消、查询是否完成、获取结果等。
  • FutrueTaskFutrue接口的唯一的实现
  • FutureTask 同时实现了Runnable, Future接口。它既可以作为Runnable被线程执行,又可以作为Future得到Callable的返回值

方式四:使用线程池

一、背景

经常创建和销毁、使用量特别大的资源,比如并发情况下的线程,对性能影响很大。

二、思路

提前创建好多个线程,放入线程池中,使用时直接获取,使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

三、优点

  • 提高响应速度(减少了创建新线程的时间)
  • 降低资源消耗(重复利用线程池中线程,不需要每次都创建)
  • 便于线程管理
    1.corePoolSize:核心池的大小
    2.maximumPoolSize:最大线程数
    3.keepAliveTime:线程没有任务时最多保持多长时间后会终止

四、步骤

  1. 提供指定线程数量的线程池
  2. 执行指定的线程操作。需要提供实现
  3. 关闭连接池
class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            if(i % 2 == 0){      System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class ThreadPool {
    public static void main(String[] args) {
        //1. 提供指定线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);
        //设置线程池的属性
        ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
        service1.setCorePoolSize(15); //设置核心池大小
//        service1.setKeepAliveTime(); //设置线程池活跃时间
        //2. 执行指定的线程操作。需要提供实现Runnable接口或Callable接口实现类的对象
        service.execute(new NumberThread());//适用于Runnable
//        service.submit(Callable callable);//适用于Callable
        //3.关闭连接池
        service.shutdown();
    }
}
最后修改:2022 年 02 月 08 日
如果觉得我的文章对你有用,请随意赞赏