JAVA多线程的四种创建方式以及简单方法

基本概念:

程序(program):是为完成特定任务、用某种语言编写的一组指令的集合,即指一堆静态的代码,静态对象。

进程(process):是程序的一次执行过程或是正在运行的一段程序、是一个动态的过程:有他自身的产生、存在和消亡过程。

线程(thread):进程可进一步细化为线程,是一个程序内部的一条执行路径。若一个进程中同一时间并行执行多个线程,就是支持多线程的。线程作为调度和执行的单位,每个线程都拥有独立的运行栈和程序计数器,一个进程中的多个线程共享相同的内存单元/内存地址空间——>他们从同一堆中分配对象,可以访问相同的变量和对象。这就使得线程间通信更简便,高效,但是多个线程操作共享的的系统资源可能就会带来安全隐患。

单核CPU:是一种假的多线程,因为在一个时间单元内也只能执行一个线程的任务。

多核CPU:才能更好发挥多线程的效率。

并行:多个CPU同时执行多个任务。比如:每个人同时做不同的事

并发:一个CPU(采用时间片)同时执行多个任务。比如:秒杀,多个人做同一件事。

一个java应用程序java.exe至少有三个线程:main()主线程,gc()垃圾回收线程,异常处理线程,如果发生异常会影响主线程。

多线程创建方式(线程安全问题没有处理):

1.继承于Thread类

public class MyThreat extends  Thread{
    @Override
    //遍历100以内偶数
    public void run() {
        for(int  i =0;i<100;i++){
            if(i%2==0){
                System.out.println(i);
                System.out.println(Thread.currentThread().getName());
       //currentThread()静态方法,返回执行当前代码线程
       //getName()获取当前线程名字
            }
        }
        System.out.println(getPriority());//获取线程优先级
    }
    public static void main(String[] args) {
        MyThreat myThread=new MyThreat();
        myThread.setPriority(10);//设置分线程优先级
        myThread .start();
        MyThreat myThread1=new MyThreat();
        myThread1 .start();
        for(int  i =0;i<100;i++){
            if(i%2==0){
                System.out.println(i+"********");
            }
        }
    }
}

yield():释放当前CPU执行权

join():在线程a中调用线程b的join(),此时线程a进入阻塞状态,直到线程b完全执行完以后,线程a才结束阻塞转态

sleep( long millitime):当前线程睡眠,指定时间当前线程阻塞

isAlive()判断当前线程是否存活

线程优先级:

//MAX_PRIORITY:10
//MIN_PRIORITY:1
//NORM_PRIORITY:5默认优先级

2.实现Runnable接口

public class MyThreat1 {
    public static void main(String[] args) {
        MyThreat1Test myThreat1Test = new MyThreat1Test();
        Thread thread = new Thread(myThreat1Test);
        Thread thread1 = new Thread(myThreat1Test);
        Thread thread2 = new Thread(myThreat1Test);
        thread.start();
        thread1.start();
        thread2.start();

    }

}
 class MyThreat1Test implements Runnable {
    @Override
    public void run() {
        for(int  i =0;i<100;i++){
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+"  "+i);

            }
        }
    }
}

继承与实现两种方式都需要重写run()方法,将线程要执行的逻辑声明在run()中。

开发中优先选择实现Runnable接口方式,因为实现的方式没有类的单继承性的局限性,而且实现的方式更适合处理多个线程有共享数据的情况。

3.实现Callable接口

public class Threadnew {
    //创建线程的方式三----Callable接口
    public static void main(String[] args)  {
        //创建callable接口实现类的对象
        numThread numthread= new numThread();
        FutureTask futureTask =new FutureTask(numthread);
        new Thread(futureTask).start();
        try {
           Object sum = futureTask.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}
//创建实现Callable接口的实现类
class numThread implements Callable {
    //实现call方法,将此线程操作放在call中
    @Override
    public Object call() throws Exception {
        int sum =0;
        for (int i = 0; i <= 100;i ++) {
            if(i%2==0) {
                System.out.println(i);
                sum += i;
            }
        }
        return sum;
    }
}

Callable接口功能更强大,支持泛型,call()可以有返回值,可以抛异常。

4.使用线程池

public class Thradpool1 {

    public static void main(String[] args) {
        //提供指定线程数量的线程池
        ExecutorService executorService = Executors.newFixedThreadPool(10);

       // executorService.submit();//适合适用于Callable
        executorService.execute(new Number2());  //适合适用于Rannable
        executorService.execute(new Number1());
        ThreadPoolExecutor executorService1 = (ThreadPoolExecutor) executorService;
        //设置线程池属性
        executorService1.setCorePoolSize(10);
        executorService1.setMaximumPoolSize(10);
      //   executorService1.setKeepAliveTime(5);
        //关闭连接池
        executorService.shutdown();
    }
}
class Number2 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+"  "+i);
            }

        }
    }
}
class Number1 implements Runnable{

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+"  "+i);
            }

        }
    }
}

使用线程池的优势:减少创建新线程时间,重复利用线程池中线程,不需要每次创建,便于线程管理。

线程的生命周期:

新建:Thread()类或其子类对象被声明创建时,就需要为线程分配内存

就绪:调用了start()等待CPU分配资源

运行:获得CPU资源,执行run()

阻塞:暂时停止执行线程,让出CPU,进入阻塞状态

死亡:线程完成全部工作或者被强行终止或者出现异常导致结束

  • 4
    点赞
  • 4
    收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:游动-白 设计师:我叫白小胖 返回首页
评论 1

打赏作者

小嘴鱼

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值