Java创建线程的四种方式

更新时间:2020-09-02 10:07:50点击次数:209次
1.继承Thread类实现多线程
run()为线程类的核心方法,相当于主线程的main()方法,是每个线程的入口

一个线程调用两次start()方法将会抛出线程状态异常,也就是start()只可以调用一次
native声明的方法只有方法名,没有方法体。是本地方法,不是抽象方法,而是调用c语言方法,registerNative()方法包含了所有与线程相关的操作系统方法
run()方法是由JVM创建完本地操作系统及线程后回调的方法,不可以手动调用,通过start调用
public class MyThread extends Thread{
       public MyThread(){
       }
       public void run(){
              for(int i=0;i<10;i++){
                   System.out.println(Thread.currentThread().getName()+":"+i");
              }
       }
       public static void main(String[] args){
              MyThread mThread1=new MyThread();
              MyThread mThread2=new MyThread();
              mThread1.start();
              mThread2.start();
       }
}

2.实现Runnable()接口实现多线程
Runnable接口实现多线程可以避免单继承局限。
当子类实现Runnable接口,此时子类和Thread属于代理模式(子类负责真实业务的操作,Thread负责资源调度与线程创建辅助真实业务)。

public class MyThread1 implements Runnable{
       public static int count=20;
       public void run(){
             while(count>0){
                  try{
                      Thread.sleep(200);
                  }catch(InterruptedException e){
                       e.printStackTrace();
                  }
                  System.out.println(Thread.currentThread().getName()+"-当前剩余票数:"+count--);
             }
       }
       public static void main(String[] args){
              MyThread1 myThread1=new MyThread1();
              Thread m1=new Thread(myThread1,"线程1");
              Thread m2=new Thread(myThread1,"线程2");
              Thread m3=new Thread(myThread1,"线程3");
              m1.start();
              m2.start();
              m3.start();     
       }
}

3.Callable接口实现多线程(JDK1.5)
核心方法叫call()方法,有返回值

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class MyThread2 implements Callable<String>{
       private int count=20;
       @Override
       public String call() throws Exception{
              for(int i=count;i>0;i--){
                     System.out.println(Thread.currentThread().getName()+"当前票数:"+i);
              }
              return "sale out";
       }
       public static void main(String[] args) throws InterruptedException,ExecutionException{
             Callable<String>  callable=new MyThread2();
             FutureTask<String> futureTask=new FutureTask<>(callable);
             Thread m4=new Thread(futureTask);
             Thread m5=new Thread(futureTask);
             Thread m6=new Thread(futureTask);
             m4.start();
             m5.start();
             m6.start();
             System.out.println(futureTask.getName());
       }
}

4.通过线程池启动多线程
通过Executor的工具类可以创建三种类型的普通线程池

FixThreadPool(int n):固定大小的线程池
使用于为了满足资源管理需求而需要限制当前线程数量的场合,使用于负载比较重的服务器。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test{
       public static void main(String[] args){
              ExecutorService ex=Executors.newFixedThreadPool(5);
              for(int i=0;i<5;i++){
                    ex.submit(new Runnable(){
                           @Override
                           public void run(){
                                  for(int j=0;j<10;j++){
                                        System.out.println(Thread.currentThread().getName()+j);
                                  }
                           }
                    });
              }
              ex.shutdown();
       }
}

SingleThreadPoolExecutor:单线程池
需要保证顺序执行各个任务的场景

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Tes1{
       public static void main(String[] args){
              ExecutorService ex1=Executors.newSingleThreadExecutor();
              for(int i=0;i<5;i++){
                    ex1.submit(new Runnable(){
                           @Override
                           public void run(){
                                 for(int j=0;j<10;j++){
                                      System.out.println(Thread.currentThread().getName()+j);
                                 }
                           }
                    });
              }
              ex1.shutdown();
       }
}

CashedThreadPool():缓存线程池
当提交任务速度高于线程池中任务处理速度时,缓存线程池会不断的创建线程,适用于提交短期异步小程序,以及负载较轻的服务器。

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Test2{
       public static void main(String[] args){
              ExecutorService ex2=Executors.newCashedThreadPool();
              for(int i=0;i<5;i++){
                    ex2.submit(new Runnable(){
                          @Override
                          public void run(){
                                 for(int j=0;j<10;j++){
                                      System.out.println(Thread.currentThread().getName()+j);
                                 }
                          }
                    });
              }
              ex2.shutdown();
       }
}

本站文章版权归原作者及原出处所有 。内容为作者个人观点, 并不代表本站赞同其观点和对其真实性负责,本站只提供参考并不构成任何投资及应用建议。本站是一个个人学习交流的平台,网站上部分文章为转载,并不用于任何商业目的,我们已经尽可能的对作者和来源进行了通告,但是能力有限或疏忽,造成漏登,请及时联系我们,我们将根据著作权人的要求,立即更正或者删除有关内容。本站拥有对此声明的最终解释权。

  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息
  • 项目经理 点击这里给我发消息