Java多线程的创建方式


Java多线程的创建方式

滴水穿石,不是力量大,而是功夫深

一、进程和线程?

进程是正在运行的程序的实例;

线程是进程内部的一个独立执行单元;

多线程是多个线程并发执行;

通俗来说就是:一个任务为工厂,进程就是车间,线程是工人,而车间内的资源是工人们共享的。

二、创建线程

1.实现Runnable接口
//继承Thread类
public class MyThread extends Thread{

  public void run(){
     //重写run方法
    }

    public static void main(String[] args){
    new MyThread().start();//创建并启动线程
  }

}
2.继承Thread类
public class MyThread2 implements Runnable {//实现Runnable接口

  public void run(){

  //重写run方法

  }

    public static void main(String[] args){

    //创建并启动线程

    MyThread2 myThread2=new MyThread2();

    Thread thread=new Thread(myThread2);

    thread().start();

    //或者 new Thread(new MyThread2()).start();

  }
}
3.使用线程池

Java通过Executors提供四种线程池,分别为:

  • newSingleThreadExecutor

    创建一个单线程化的线程池,它只会用唯一的工作线程来执行任务,保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

    /** 
        *
        * 创建只有一个线程的线程池,且线程的存活时间是无限的;当该线程正繁忙时,对于新任务会进入阻塞队列中(无界        的阻塞队列)
        * 适用:一个任务一个任务执行的场景
         */
        public static void singleTheadPoolTest() {
            ExecutorService pool = Executors.newSingleThreadExecutor();
            for (int i = 0; i < 10; i++) {
                final int ii = i;
                pool.execute(() -> out.println(Thread.currentThread().getName() + "=>" + ii));
            }
        }
    
    -----output-------
     线程名称:pool-1-thread-1,执行0
     线程名称:pool-1-thread-1,执行1
     线程名称:pool-1-thread-1,执行2
     线程名称:pool-1-thread-1,执行3
     线程名称:pool-1-thread-1,执行4
     线程名称:pool-1-thread-1,执行5
     线程名称:pool-1-thread-1,执行6
     线程名称:pool-1-thread-1,执行7
     线程名称:pool-1-thread-1,执行8
     线程名称:pool-1-thread-1,执行9
  • newFixedThreadPool

    创建一个定长线程池,可控制线程最大并发数,超出的线程会在队列中等待。

    /**
         * 创建可容纳固定数量线程的池子,每隔线程的存活时间是无限的,当池子满了就不在添加线程了;如果池中的所有        线程均在繁忙状态,对于新任务会进入阻塞队列中(无界的阻塞队列)
        * 适用:执行长期的任务,性能好很多
         */
        public static void fixTheadPoolTest() {
            ExecutorService fixedThreadPool = Executors.newFixedThreadPool(3);
            for (int i = 0; i < 10; i++) {
                final int ii = i;
                fixedThreadPool.execute(() -> {
                    out.println("线程名称:" + Thread.currentThread().getName() + ",执行" + ii);
                    try {
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                });
            }
        }
    ------output-------
    线程名称:pool-1-thread-3,执行2
    线程名称:pool-1-thread-1,执行0
    线程名称:pool-1-thread-2,执行3
    线程名称:pool-1-thread-3,执行4
    线程名称:pool-1-thread-1,执行5
    线程名称:pool-1-thread-2,执行6
    线程名称:pool-1-thread-3,执行7
    线程名称:pool-1-thread-1,执行8
    线程名称:pool-1-thread-3,执行9
  • newScheduledThreadPool

    创建一个可定期或者延时执行任务的定长线程池,支持定时及周期性任务执行。

    /**
         * 创建一个固定大小的线程池,线程池内线程存活时间无限制,线程池可以支持定时及周期性任务执行,如果所有线        程均处于繁忙状态,对于新任务会进入DelayedWorkQueue队列中,这是一种按照超时时间排序的队列结构
        * 适用:周期性执行任务的场景
         */
        public static void sceduleThreadPool() {
            ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(5);
            Runnable r1 = () -> out.println("线程名称:" + Thread.currentThread().getName() + ",执行:3秒后执行");
            scheduledThreadPool.schedule(r1, 3, TimeUnit.SECONDS);
            Runnable r2 = () -> out.println("线程名称:" + Thread.currentThread().getName() + ",执行:延迟2秒后每3秒执行一次");
            scheduledThreadPool.scheduleAtFixedRate(r2, 2, 3, TimeUnit.SECONDS);
            Runnable r3 = () -> out.println("线程名称:" + Thread.currentThread().getName() + ",执行:普通任务");
            for (int i = 0; i < 5; i++) {
                scheduledThreadPool.execute(r3);
            }
        }
    ----output------
    线程名称:pool-1-thread-1,执行:普通任务
    线程名称:pool-1-thread-5,执行:普通任务
    线程名称:pool-1-thread-4,执行:普通任务
    线程名称:pool-1-thread-3,执行:普通任务
    线程名称:pool-1-thread-2,执行:普通任务
    线程名称:pool-1-thread-1,执行:延迟2秒后每3秒执行一次
    线程名称:pool-1-thread-5,执行:3秒后执行
    线程名称:pool-1-thread-4,执行:延迟2秒后每3秒执行一次
    线程名称:pool-1-thread-4,执行:延迟2秒后每3秒执行一次
    线程名称:pool-1-thread-4,执行:延迟2秒后每3秒执行一次
    线程名称:pool-1-thread-4,执行:延迟2秒后每3秒执行一次
  • newCachedThreadPoo

    创建一个可缓存线程池,如果线程池长度超过处理需要,可灵活回收空闲线程,若无可回收,则新建线程。

    /**
         * 当有新任务到来,则插入到SynchronousQueue中,由于SynchronousQueue是同步队列,因此会在池中寻找可用            线程来执行,若有可以线程则执行,若没有可用线程则创建一个线程来执行该任务;若池中线程空闲时间超过         指定大小,则该线程会被销毁。
            适用:执行很多短期异步的小程序或者负载较轻的服务器
         */
        public static void cacheThreadPool() {
            ExecutorService cachedThreadPool = Executors.newCachedThreadPool();
            for (int i = 1; i <= 10; i++) {
                final int ii = i;
                try {
                    Thread.sleep(ii * 1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                cachedThreadPool.execute(()->out.println("线程名称:" + Thread.currentThread().getName() + ",执行" + ii));
            }
    
        }
    -----output------
    线程名称:pool-1-thread-1,执行1
    线程名称:pool-1-thread-1,执行2
    线程名称:pool-1-thread-1,执行3
    线程名称:pool-1-thread-1,执行4
    线程名称:pool-1-thread-1,执行5
    线程名称:pool-1-thread-1,执行6
    线程名称:pool-1-thread-1,执行7
    线程名称:pool-1-thread-1,执行8
    线程名称:pool-1-thread-1,执行9
    线程名称:pool-1-thread-1,执行10

    参考:


文章作者: Athink
版权声明: 本博客所有文章除特別声明外,均采用 CC BY 4.0 许可协议。转载请注明来源 Athink !
评论
  目录