java线程

最新推荐文章于 2025-04-22 13:49:06 发布

fazem

最新推荐文章于 2025-04-22 13:49:06 发布

阅读量78

点赞数

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/fazem/article/details/134318202

版权

Java 专栏收录该内容

1 篇文章

订阅专栏

本文详细解析了程序、进程、线程之间的关系，介绍了VxWorks内核下的任务概念，以及在Java中通过继承Thread、实现Runnable和Callable接口创建线程的方式。此外，还讨论了线程的生命周期管理、线程优先级和守护线程的作用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

程序，进程，线程

任务是代码运行的一个映象，从系统的角度看，任务是竞争系统资源的最小运行单元。任务可以使用或等待CPU、I/O设备及内存空间等系统资源，并独立于其它任务，与它们一起并发运行（宏观上如此）。VxWorks内核使任务能快速共享系统的绝大部分资源。

在VxWorks6.4中，进程是指Rtp，进程包含任务，任务是调度的最小单元。

程序(Program) :为了完成特定功能,一组计算机指令的集合,是一个静态概念;
进程(Process):运行中的程序实例,操作系统进行 资源分配和调度 的基本单位,一个程序在运行时,至少有一个进程;
线程(Thread):进程中的一个指令执行序列,是CPU调度的基本单位,一个进程至少有一个线程,一个进程中的多个线程代表不同执行的序列;

线程创建的三种方式

1、继承Thread类

自定义线程类继承Thread类
重写run方法
调用start类开启线程

public class thread  extends Thread{

    //继承thread类
    //实现runnable接口
    //实现callable接口
    @Override
    public void run() {
        //run方法线程体
        for(int i=1;i<=30;i++)
            System.out.println("我在学习-------"+i);
    }

    public static void main(String[] args) {
        System.out.println("hello world");
        //main线程，主线程

        //创建一个线程对象
       thread th = new thread();
       th.start();//调用start方法开启线程

        for (int i=1;i<=30;i++)
            System.out.println("我在play--------"+i);
        //线程开启不一定立即执行，由CPU调度执行
    }
}

子类继承Thread类具备多线程能力
启动线程：子类对象.start（）
不建议使用:避免OOP单继承局限性

2、实现Runnable接口

实现接口Runnable具有多线程能力
启动线程:传入目标对象+Thread对象.start（）
推荐使用:避免单继承局限性，灵活方便，方便同一个对象被多个线程使用

public class runnable implements Runnable {
    public static void main(String[] args) {
        System.out.println("hello world");
        //main线程，主线程
        //创建一个线程对象
        new Thread(new runnable()).start();
       //调用start方法开启线程

        for (int i=1;i<=30;i++)
            System.out.println("我在play--------"+i);
        //线程开启不一定立即执行，由CPU调度执行

    }

    @Override
    public void run() {
        for(int i=1;i<=30;i++)
            System.out.println("我在学习-------"+i);
    }
}

模拟龟兔赛跑

public class race implements Runnable{
    private static  String winner;
    public static void main(String[] args) {
        new Thread(new race(),"兔子子子").start();
        new Thread(new race(),"乌龟龟龟").start();
    }

    @Override
    public void run() {
        for (int i = 0; i <=200; i++) {
            if(Thread.currentThread().getName().equals("兔子子子")&&i%200==0){
                try {
                    Thread.sleep(1);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            //判断比赛是否结束
            boolean flag = gameover(i);
            if (flag) break;
            System.out.println(Thread.currentThread().getName()+"----->跑了"+i+"米");
        }
    }
    private boolean gameover(int steps){
        //判断是否有胜利者
        if (winner!=null)
            return true;
        if (steps==200) {
            winner = Thread.currentThread().getName();
            System.out.println("winner is"+winner);
        }
        return false;
    }
}

3、实现Callable接口（了解即可)

实现collable接口，重写call方法，返回值是Boolean类型

静态代理

//静态代理模式
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处:
//代理对象可以做很多真实对象做不了的事情，真实对象专注自己的事情

public class StaticProxy {
    public static void main(String[] args) {
        WeddingCompany weddingCompany = new WeddingCompany(new You());
        weddingCompany.HappyMarry();
        //本来就you.happy marry就好了，现在引进第三方来代理，
    }
}
//静态代理模式
//真实对象和代理对象都要实现同一个接口
//代理对象要代理真实角色
//好处
//代理对象可以做很多真实对象做不了的事情，真实对象专注自己的事情
interface Marry{

    Void HappyMarry();
}
class You implements Marry{

    @Override
    public Void HappyMarry() {
        System.out.println("你要结婚了");
        return null;
    }
}
class WeddingCompany implements Marry{
private  Marry taget;
public  WeddingCompany(Marry taget){
    this.taget = taget;
}
    @Override
    public Void HappyMarry() {
        before();
        this.taget.HappyMarry();//这就是真实对象
        after();
        return null;
    }

    private void after() {
        System.out.println("结婚之后------>异常暴躁");
    }

    private void before() {
        System.out.println("结婚之前------>非常开心");
    }
}

静态代理就是线程的实现原理。------->米奇妙妙屋

Lambda表达式

避免匿名内部类过多

可以让代码看起来简洁

去掉一堆没有意义的代码，只留下核心的逻辑

函数式接口----->一个接口内只有一个抽象方法

一般形式:

public class Lambda1 {
    public static void main(String[] args) {
        new Like().lambda();
    }
}
//定义一个函数式接口
interface Ilike{
    void lambda();
}
class Like implements Ilike{

    @Override
    public void lambda() {
        System.out.println("I like Lambda");
    }
}

public class Lambda1 {
    //静态内部类
   static class Like1 implements Ilike{

        @Override
        public void lambda() {
            System.out.println("I like Lambda1----静态内部类");
        }
    }
    public static void main(String[] args) {
        new Like().lambda();
        new Like1().lambda();
        //局部内部类
        class Like2 implements Ilike {

            @Override
            public void lambda() {
                System.out.println("I like Lambda2----局部内部类");
            }
        }
        new Like2().lambda();
        //匿名内部类
        Like like = new Like() {
            @Override
            public void lambda() {
                System.out.println("I like Lambda3---匿名内部类");
            }
        };
        like.lambda();

//lambda表达式
        Ilike li = new Like();
        li = ()->{
            System.out.println("Lambda");
        };
        li.lambda();
    }
}
//定义一个函数式接口
interface Ilike{
    void lambda();
}
class Like implements Ilike{

    @Override
    public void lambda() {
        System.out.println("I like Lambda----公共类");
    }
}

lambda的简化:

public class lambda2 {
    public static void main(String[] args) {
        Ilove love = (a)->{
            System.out.println("I love you "+a);
        };
        love.love("LC");
        Ilove l = a->{
            System.out.println("you love me "+a);
        };
        l.love("LC ");
        Ilove o = a-> System.out.println("HAHAHAH"+a);
                o.love("wuwuuw,我函数体都没了");

    }
}
interface Ilove{
    void love(String a);
}

总结：

lambda表达式只能有一行代码的情况下才能简化成一行，如果有多行，则要用代码块包裹
前提是接口为函数式接口
多个参数也能去掉参数类型，要去掉都去掉，必须加括号

线程停止

不推荐使用JDK提供的stop等方法（已废弃）

推荐线程自己停下来

建议使用一个标志位进行终止变量，当flag=false，则终止线程运行

//1.建议线程正常停止---->利用次数，不建议死循环
//建议使用标志位
public class testStop implements  Runnable{
//设置一个标志位
   private boolean flag =true;
    @Override
    public void run() {
        int i =0;
        while (flag){
            System.out.println("run……Thread"+i++);
        }
    }
    //设置一个公开的方法停止线程，转换标志位
public void stop(){
        this.flag=false;
}
    public static void main(String[] args) {
        testStop t=new testStop();
        new Thread(t).start();
        for (int i = 0; i < 200; i++) {
            System.out.println("main"+i);
            if (i==150){
                t.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

线程休眠

sleep（）指定当前线程阻塞的毫秒数
sleep存在异常InterruptedException;
sleep时间达到后线程进入就绪状态
sleep可以模拟网络延时，倒计时等
每一个对象都有一个锁，sleep不会释放锁

计时器和显示当前时间

import java.text.SimpleDateFormat;
import java.util.Date;

//模拟倒计时
public class testSleep {
    public static void main(String[] args) throws InterruptedException {

      tenDown();
        Date date = new Date(System.currentTimeMillis());
        while(true){
            Thread.sleep(1000);
            System.out.println(new SimpleDateFormat("HH:mm:ss").format(date));
           date = new Date(System.currentTimeMillis());//更新当前时间
        }
    }
    public static void tenDown(){
        int num =10;
        while(true){
            try {
                Thread.sleep(1000);//模拟倒计时
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println(num--);
            if (num<=0)break;
        }
    }
}

线程礼让

让当前执行的线程暂停，但不阻塞

让线程从运行状态转为就绪状态

让CPU重新调度，礼让不一定成功

public class testYield {
    //礼让不一定成功，看cpu
    public static void main(String[] args)

    {

        new Thread(new MyYield(),"ddd").start();
        new Thread(new MyYield(),"aaa").start();

    }

}
class MyYield implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程正在执行");
        Thread.yield();
        System.out.println(Thread.currentThread().getName()+"线程停止执行");


    }
}

线程强制执行

插队

public class testJoin implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("线程VIP来了"+i);
        }
    }
    //插队
    public static void main(String[] args) throws InterruptedException {
       Thread thread= new Thread(new testJoin());
       thread.start();
        //主线程
        for (int i = 0; i < 300; i++) {
            if(i==200)
            {
                thread.join();
            }
            System.out.println("main"+i);
        }
    }
}

线程优先级

先设置优先级，再启动线程

public class testPriority {
    //测试线程的优先级
    public static void main(String[] args) {
        //主线程默认优先级
        System.out.println(Thread.currentThread().getName()+"------>"+Thread.currentThread().getPriority());

        Mypriority mypriority = new Mypriority();
       Thread t =  new Thread(mypriority);
       Thread t2 =  new Thread(mypriority);
       Thread t3 =  new Thread(mypriority);
       Thread t4 =  new Thread(mypriority);
       Thread t5 =  new Thread(mypriority);
       Thread t6 =  new Thread(mypriority);

       //先设置优先级，再启动
        t.start();t2.setPriority(1);
        t2.start();t3.setPriority(9);
        t3.start();t4.setPriority(Thread.MIN_PRIORITY);
        t4.start();t5.setPriority(5);
        t5.start();t6.setPriority(Thread.MAX_PRIORITY);
        t6.start();t.setPriority(4);
    }
}
class Mypriority implements  Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"------>"+Thread.currentThread().getPriority());
    }
}