当前位置: 主页 > JAVA语言

java多线程框架推荐-Java线程的使用方法和属性分析:线程

发布时间:2023-06-24 16:07   浏览次数:次   作者:佚名

前言

在java中一个线程是使用Thread的实例来表示,所有线程对象都必须是Thread的子类实例或是Thread的实例,它位于java.lang包中,是Java中非常常用也是非常重要的一个基础类。Thread类实现了Runnable接口,它有不少非常重要的方法和属性:

java线程框架_java多线程框架推荐_linux线程池的通用框架

java线程框架_java多线程框架推荐_linux线程池的通用框架

那么创建Java的线程一般有哪几种方式呢?一、继承Thread类创建线程类

1. 定义Thread类的子类ThreadDemo,并重写该Thread类的run()方法java多线程框架推荐,在run()方法中执行该线程的主要逻辑。

2. 在主线程上创建Thread子类的实例,即创建了一个线程对象。

3. 调用线程对象的start()方法来启动该线程。

// 继承Thread类,创建一个新的线程类
public class ThreadDemo extends Thread{
    // 重写了Thread类的run()方法,将需要并发执行的用户业务代码编写在继承的run()方法中
    @Overrite
    public void run(){
        System.out.println(getName()+" 这里执行线程的业务逻辑");
    }
}

public class AppDemo {
    public static void main(String[] args) {
        ThreadDemo threadDemo = new ThreadDemo();
        // 启动线程
        threadDemo.start();
        System.out.println("线程名:"+Thread.currentThread().getName()+" 运行结束");
    }
}

执行结果:

线程名:main 运行结束

Thread-0 这里执行线程的业务逻辑

二、实现Runnable接口,创建线程目标类

linux线程池的通用框架_java线程框架_java多线程框架推荐

有了Thread类了,为什么还需要多一个Runnable的接口方式来创建一个线程呢?那是因为Java继承的一个特征,extend只能一个父类,当一个子类已经继承了一个父类时,此时你希望这个类成为一个线程类,是不行的,但它能实现Runnable接口。

1.定义Runnable接口的实现类,并实现run()方法,在run()方法中执行该线程的主要逻辑。

⒉.创建Runnable实现类的实例,并将其作为Thread的target来创建Thread对象,Thread对象为线程对象。

3.调用线程对象的start()方法来启动该线程。

public class RunnableThreadDemo implements Runnable {
    // 重写了Runnable类的run()方法,将需要并发执行的用户业务代码编写在继承的run()方法中
    @0verrite
    public void run( ){
        System.out.println(Thread.currentThread().getName()+" 这里执行线程的业务逻辑" )
    }
}

public class AppDemo {
    public static void main(String[] args) {
        RunnableThreadDemo threadDemo = new RunnableThreadDemo();
        // 启动线程
        threadDemo.start();
        System.out.println("线程名:"+Thread.currentThread().getName()+" 运行结束");
    }
}

执行结果:

线程名:main 运行结束

Thread-0 这里执行线程的业务逻辑

三、使用匿名内部类,实现创建Thread子类

跟方式一类似,只是不需要创建一个单独的类文件来继承Thread,而是使用了匿名类来完成,代码如下:

public class AppDemo {
    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println(getName()+" 这里执行线程的业务逻辑");
            }
        };
        thread.start();
        System.out.println("线程名:"+Thread.currentThread().getName()+" 运行结束");
    }
}

java多线程框架推荐_linux线程池的通用框架_java线程框架

执行结果:

线程名:main 运行结束

Thread-0 这里执行线程的业务逻辑

四、使用匿名内部类,实现Runnable接口

跟方式二类似,区别在于使用匿名类来完成,代码如下:

public class AppDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable(){
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+" 这里执行线程的业务逻辑" );
            }
        });
        thread.start();
        System.out.println("线程名:"+Thread.currentThread().getName()+" 运行结束");
    }
}

执行结果:

Thread-0 这里执行线程的业务逻辑

线程名:main 运行结束

什么?这跟方式二执行的结果不一样?这里是没问题的,这里是两个线程在跑着,哪个线程先跑是跟cpu的调度有关,跟代码的先后无关。这点请紧记。

五、使用lambda表达式来完成

使用lambda表达式使得代码更简洁,实现其实跟方式三一样,只是使用lambda来代替匿名类。

java线程框架_linux线程池的通用框架_java多线程框架推荐

public class AppDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            System.out.println(Thread.currentThread().getName()+" 这里执行线程的业务逻辑");
        });
        thread.start();
        System.out.println("线程名:"+Thread.currentThread().getName()+" 运行结束");
    }
}

执行结果:

线程名:main 运行结束

Thread-0 这里执行线程的业务逻辑

六、实现Callable接口

继承Thread类或者实现Runnable接口这两种方式来创建线程类有一个缺陷,就是不能获取异步执行的结果,即在主线程启动子线程后,能run起来就分道扬镳了,但在很多场景上需要获取到异步执行的结果,这个时候就需要实现Callable接口了。这是在1.5之后提供的一种创建多线程的方法,通过Callable接口和FutureTask类互相作用来完成线程执行以及在主线程中获取执行的结果。

Callable接口位于java.util.concurrent包中:

@FunctionalInterface
public interface Callable {
    V call() throws Exception;
}

创建步骤如下:

首先定义一个 Callable 的实现类,并实现call方法。call方法是带返回值的。然后通过FutureTask的构造方法,把这个Callable 实现类传进去。把 FutureTask作为 Thread 类的 target ,创建Thread线程对象。通过FutureTask 的get方法获取线程的执行结果。

public class CallableTaskDemo implements Callable {
    // 编写好异步执行的具体逻辑,可以有返回值。
    // (Runnable接口中的run()方法是没有返回值得,Callable接口的call()方法有返回值)
    @Override
    public Long call() throws Exception {
        Long startTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName()+" 线程开始运行");
        Thread.sleep(1000);
        for(int i=0;i<100000000;i++){
            int j = i*10000;
        }
        Long endTime = System.currentTimeMillis();
        Long used = endTime-startTime;
        System.out.println(Thread.currentThread().getName()+" 线程结束运行");
        return used;
    }
}

public class AppDemo {
    public static void main(String[] args) throws InterruptedException {
        CallableTaskDemo callableTaskDemo = new CallableTaskDemo();
        FutureTask futureTask = new FutureTask(callableTaskDemo);
        Thread thread = new Thread(futureTask,"callableTaskThread");
        thread.start();
        Thread.sleep(500);
        System.out.println("main线程执行一会");
        for(int i=0;i<100000000/2;i++){
            int j = i*10000;
        }
        // 获取并发任务的执行结果
        try {
            System.out.println(thread.getName()+" 线程占用时间:"+futureTask.get());
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

java线程框架_java多线程框架推荐_linux线程池的通用框架

执行结果:

callableTaskThread 线程开始运行

main线程执行一会

callableTaskThread 线程结束运行

callableTaskThread 线程占用时间:1008

七、使用自带线程池

使用线程池的一个很重要的原因是线程的复用性。我们知道线程资源在服务器上来看java多线程框架推荐,是一种非常昂贵的资源,如果使用不当,服务器的负载是非常高,并且可能会出现超负荷的情况,往往会导致服务器死机等问题,所以线程的合理分配就变得是一个非常有意思的话题。线程池往往就能很好地解决这个问题,设定一个线程池,往线程池中注入固定的线程数,超过的线程的任务数,要不等待,要不抛弃。大大地复用了线程,减少线程频繁创建与销毁,提高了服务器的可用率。

Java在线程池上也有多种类型的支持,在不同的场景下可选择不同类型的线程池。

一般的使用方式如下:

首先,定义一个 Runnable 的实现类,重写run方法然后创建一个拥有固定线程数的线程池最后通过ExecutorService对象的execute 方法传入线程对象

public class RunnableTaskDemo implements Runnable {
    @Override
    public void run() {
        for(int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+" 轮次:"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

public class CallableTaskDemo implements Callable {
    @Override
    public Long call() throws Exception {
        Long startTime = System.currentTimeMillis();
        System.out.println(Thread.currentThread().getName()+" 线程开始运行");
        for(int i=0;i<3;i++){
            System.out.println(Thread.currentThread().getName()+" 轮次:"+i);
            Thread.sleep(1000);
        }
        Long used = System.currentTimeMillis()-startTime;
        System.out.println(Thread.currentThread().getName()+" 线程结束运行");
        return used;
    }
}

java多线程框架推荐_java线程框架_linux线程池的通用框架

public class AppDemo {
    private static ExecutorService threadpool = Executors.newFixedThreadPool(3);
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1、执行Runnbale类型的target目标实例,无返回
        threadpool.execute(new RunnableTaskDemo());
        //2、 执行Runnbale类型的target目标实例,无返回,内部类形式
        threadpool.execute(new Runnable() {
            @Override
            public void run() {
                for(int i=0;i<3;i++){
                    System.out.println(Thread.currentThread().getName()+" 轮次:"+i);
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }       
        });
        // 3、提交Callable执行目标实例,有返回
        Future future = threadpool.submit(new CallableTaskDemo());
        System.out.println("异步执行的结果为:" + future.get());
    }
}

执行结果:

pool-1-thread-1 轮次:0

pool-1-thread-2 轮次:0

pool-1-thread-3 线程开始运行

pool-1-thread-3 轮次:0

pool-1-thread-2 轮次:1

pool-1-thread-1 轮次:1

pool-1-thread-3 轮次:1

pool-1-thread-2 轮次:2

pool-1-thread-1 轮次:2

pool-1-thread-3 轮次:2

pool-1-thread-3 线程结束运行

异步执行的结果为:3002