当前位置：主页 > JAVA语言

el表达式调用java方法-关于Java创建线程的一些常见问题及解决办法

发布时间：2023-06-17 10:08 浏览次数：次作者：佚名

1.创建线程的四种方式

Java使用Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。这里有四种方式可以实现Java创建线程：

1.继承Thread类并重写run()方法

2.实现Runnable接口并重写run()方法

3.通过匿名内部类的方式创建Thread和实现Runnable

4.通过lambda表达式来实现一个线程

1.1继承Thread类

Thread类是JDK中提供的表示线程的类。

重写run()方法，让线程执行指定的任务。

package lesson01;
public class Demo01_Thread {
    public static void main(String[] args) {
        //创建自己定义的线程对象
        MyThread thread=new MyThread();
        //执行这个线程start方法是启动线程，并通知操作系统加入CPU调度
        thread.start();
    }
}
class MyThread extends Thread{
    //run方法中的代码，就表示线程要执行的任务
    @Override
    public void run() {
        System.out.println("hello thread...");
    }
}

调用start()方法之后，JVM会调用系统API，并在系统中生成一个PCB来执行run()方法中的代码。

el表达式使用java函数_el表达式调用java方法_el表达式调用java方法

1.2实现Runnable接口

使用runnable接口定义任务的好处：

1.解耦（即把不同的功能都给分开，如果要修改或查找相应的功能的时候可以直接指定的位置找），把定义线程，与定义任务分开。

2.把创建线程，与定义任务分开，以便修改代码时，可以统一修改。

package lesson01;
public class Demo03_Runnable {
    public static void main(String[] args) {
        //创建Runnable对象
        MyRunnable runnable=new MyRunnable();
        //创建线程
        Thread thread=new Thread(runnable);
        //启动线程，参与CPU调度
        thread.start();
    }
}
//实现runnable接口
class MyRunnable implements Runnable{
    @Override
    public void run() {
        while(true){
            System.out.println("生产皮包，金币+1...");
            try{
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

1.3匿名内部类

通过匿名内部类的方式创建线程。

package lesson01;
//通过匿名内部类的方式创建线程
public class Demo05_Thread_Anon {
    public static void main(String[] args) {
        Thread thread=new Thread(){
            @Override
            public void run() {
                while(true){
                    System.out.println("hello thread");
                    try{
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        };
        thread.start();
    }
}

通过匿名内部类的方式实现Runnable接口。

package lesson01;
public class Demo06_Runnable_Anon {
    public static void main(String[] args) {
        Thread thread=new Thread(new Runnable() {
            @Override
            public void run() {
                while(true){
                    System.out.println("hello runnable");
                    try{
                        Thread.sleep(1000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        });
        thread.start();
    }
}

1.4lambda表达式

要使用lambda表达式实现接口，接口必须是一个函数式接口（即接口定义中el表达式调用java方法，只有一个方法）。

格式：()->{要执行的代码块}

package lesson01;
public class Demo07_Lambda {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            while(true){
                System.out.println("hello lambda...");
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
        thread.start();
    }
}

2.多线程的优势-增加运行速度

使用多线程编程主要是为了充分利用CPU资源，提升程序效率。

el表达式调用java方法_el表达式使用java函数_el表达式调用java方法

示例：分别对两个变量进行10亿次的自增。

1.串行：单线程

2.并行：多线程

定义次数：

private static long COUNT=10_0000_0000L;

串行操作，单线程：

private static void serial() {
        //记录开始时间
        long begin=System.currentTimeMillis();
        //第一个变量
        long a=0l;
        for(int i=0;i


并行操作，多线程：

private static void concurrency() throws InterruptedException{
        //记录开始时间
        long begin=System.currentTimeMillis();
        //创建第一个线程
        Thread t1=new Thread(()->{
            long a=0l;
            for(int i=0;i{
            long b=0l;
            for(int i=0;i

来看看结果吧：

并行执行时间确实比串行执行时间短，可却不是串行的1/2，是因为每创建一个线程都是要消耗时间和资源的。
当把计算量改小一点：
private static long COUNT=10_000L;

结果就变成了：

所以并不是所有场景都适合使用多线程，是否使用需根据计算量来确定。
3.Thread类及常用方法 3.1构造方法
方法
说明
Thread()
创建线程对象
Thread(Runnable target)
使用 Runnable 对象创建线程对象
Thread(String name)
创建线程对象el表达式调用java方法，并命名
Thread(Runnable target, String name)
使用 Runnable 对象创建线程对象，并命名

【了解】Thread(ThreadGroup group,Runnable target)
线程可以被用来分组管理，分好的组即为线程组
Thread t1 = new Thread();
Thread t2 = new Thread(new MyRunnable());
Thread t3 = new Thread("这是我的名字");
Thread t4 = new Thread(new MyRunnable(), "这是我的名字");

想要获取当前线程的名字，可以用下面这个方法：
Thread.currentThread().getName()

3.2常见属性
属性
获取方法
ID
getId()
名称
getName()
状态
getState()
优先级
getPriority()
是否后台线程
isDaemon()
是否存活
isAlive()
是否被中断
isInterrupted()
代码示例：创建一个名为”大圣“的线程，查看它的各种属性
package lesson02;
public class Demo10 {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            while(true){
                System.out.println("hello thread...");
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        },"大圣");
        thread.start();
        //打印thread对象中的属性
        System.out.println("线程ID="+thread.getId());
        System.out.println("线程名="+thread.getName());
        System.out.println("线程状态"+thread.getState());
        System.out.println("线程优先级"+thread.getPriority());
        System.out.println("线程是否后台"+thread.isDaemon());
        System.out.println("线程是否存活"+thread.isAlive());
        System.out.println("线程是否中断"+thread.isInterrupted());
    }
}


演示后台线程
创建线程时，默认是前台线程。
这里在线程启动前传入true设置线程为后台线程。
//在线程启动之前设置线程是否为后台
        thread.setDaemon(true);


代码示例：将线程设置为后台线程，main方法中是一个循环
package lesson02;
public class Demo11_Daemon {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            while(true){
                System.out.println("hello thread...");
                //休眠一秒钟
                try{
                    Thread.sleep(1000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
        });
        //在线程启动之前设置线程是否为后台
        thread.setDaemon(true);
        System.out.println("是否存活"+thread.isAlive());
        //启动线程
        thread.start();
        //休眠一会儿，确保PCB被创建成功
        Thread.sleep(500);
        System.out.println("是否存活"+thread.isAlive());
        System.out.println("main线程执行完成");
        System.out.println("是否存活"+thread.isAlive());
    }
}

结果：

程序退出了,因为main方法运行完了，后台线程影响不了程序是否退出，前台线程可以影响。

演示线程是否存活
演示线程启动前后的状态。
package lesson02;
public class Demo12_Alive {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            int count=0;
            while(true){
                System.out.println("hello thread...");
                try{
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //执行5次后退出线程
                count++;
                if(count==5){
                    break;
                }
            }
        });
        System.out.println("线程启动前的状态："+thread.isAlive());
        thread.start();
        System.out.println("线程启动后的状态："+thread.isAlive());
        
        try{
            //等待子线程执行完成
            thread.join();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("线程执行完成的状态："+thread.isAlive());
        System.out.println("主线程执行完成");
    }
}

看一看结果吧：

thread.isAlive()指的是系统的线程（PCB）是否存活，并不是我们new出来的Thread对象。
3.3线程中断
线程中断指的是停止或中断当前线程的任务。
1.通过是否中断的标志位
    //定义一个中断标识
    private static boolean isQuit=false;

子线程处理任务3秒后，将标志位改为true，线程停止。
package lesson02;
public class Demo13_Interrupted01 {
    //定义一个中断标识
    private static boolean isQuit=false;
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            while(!isQuit){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行结束");
        });
        //启动线程
        thread.start();
        //主线程休眠3秒，模拟子线程正在处理任务
        Thread.sleep(3000);
        //设置中断标志位为true
        isQuit=true;
        //让子线程先结束
        Thread.sleep(1000);
        System.out.println("主线程执行结束");
    }
}


2.通过调用Thread类提供的Interrupted方法来中断
System.out.println("是否中断："+Thread.currentThread().isInterrupted());


默认为false。
示例代码：
package lesson02;
public class Demo14_Interrupted02 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            while(!Thread.currentThread().isInterrupted()){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //异常处理中断线程
                    //方式一：什么都不做
                    //方式二：处理具体的逻辑
                    //方式三：真正的中断
                    break;
                }
            }
            System.out.println("是否中断："+Thread.currentThread().isInterrupted());
            System.out.println("线程任务结束");
        });
        //启动线程
        thread.start();
        //主线程休眠3秒，模拟子线程正在处理任务
        Thread.sleep(3000);
        //中断线程，修改Thread中的中断标志
        thread.interrupt();
        //让子线程先结束
        Thread.sleep(1000);
        System.out.println("主线程执行结束");
    }
}

运行结果：

sleep interrupted报错原因：
当线程在sleep或是阻塞状态的时候，调用interrupted方法，会中断当前的sleep休眠状态，并抛出异常。只有当线程在运行状态时，才会真正结束线程。

3.4线程等待-join()
join方法：明确等待线程的结束
方法
说明
public void join()
等待线程结束
public void join(long millis)
等待线程结束，最多等 millis 毫秒
public void join(long millis, int nanos)
同理，但可以更高精度
代码示例：
package lesson02;
public class Demo15_Join {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            for(int i=0;i<5;i++){
                System.out.println("hello thread"+i);
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行结束");
        });
        //启动线程
        thread.start();
        System.out.println("join之前，线程状态："+thread.getState());
        System.out.println("join之前，是否存活："+thread.isAlive());
        //使用join等待thread线程结束
        try{
            thread.join();
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("join之后，线程状态："+thread.getState());
        System.out.println("join之后，是否存活："+thread.isAlive());
        System.out.println("主线程执行完成");
    }
}

运行结果：

3.5获取当前线程
方法
说明
public static Thread currentThread();
返回当前线程的引用
public class ThreadDemo {
    public static void main(String[] args) {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());
   }
}

3.6启动线程-start()
run()方法和start()方法的区别：
run()方法：定义线程要执行的任务
start()方法：申请一个真正的系统线程（线程开始运行）
1.直接调用run()方法，并不会取申请一个真正的系统线程（PCB），只是单纯的调用对象的方法。
2.调用start()方法，JVM会调用本地方法取系统中真正的申请一个线程（PCB），并执行run()方法中的逻辑。
示例代码：
start()方法：
package lesson02;
public class Demo16_StartRun {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            while(true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //启动线程
        thread.start();
        System.out.println("线程状态："+thread.getState());
        System.out.println("主线程结束");
    }
}


结果：

run()方法：
package lesson02;
public class Demo16_StartRun {
    public static void main(String[] args) {
        Thread thread=new Thread(()->{
            while(true){
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        //启动线程
        thread.run();
        System.out.println("线程状态："+thread.getState());
        System.out.println("主线程结束");
    }
}

结果：

4.线程状态
线程状态指的是Thread对象的状态，不是PCB的状态。（Thread对象有自己的生命周期）
状态
解释
NEW
创建了一个Java线程，但还未调用start()方法
RUNNABLE
运行或在就绪队列中
TERMINATED
线程执行完成，PCB在操作系统中已销毁，但是Java对象还在
TIMED_WATING
等待一段时间（有时间限制）
WAITING
没有时间限制的等待
BLOCK
等待锁的时候进入的阻塞状态
示例代码：
package lesson02;
public class Demo17_State {
    public static void main(String[] args) throws InterruptedException {
        Thread t1=new Thread(()->{
            //第一种情况
            for(int i=0;i<1000_0000_00;i++){
                //啥也不干，等着让它结束
            }
            System.out.println("线程结束");
        });
        //启动之前打印一下线程状态
        //当前只是New出来了一个Thread类的对象
        System.out.println("启动之前的状态："+t1.getState());
        //真正启动线程
        t1.start();
        System.out.println("启动之后的状态："+t1.getState());
        //等待线程结束
        t1.join();
        System.out.println("PCB是否存活："+t1.isAlive());
        System.out.println("线程执行完成后的状态："+t1.getState());
    }
}

运行结果：

可以看到线程创建完成，但还没启动时状态为new，启动之后正在运行，状态为runnable，任务执行完成之后，PCB销毁，状态为terminated。
补充：
状态图


          
               java软件工程师-Java软件工程师——职业大揭秘揭秘一工作内容   上一篇 
                        
                        下一篇   java学习笔记-Java学习的小技巧，帮助你更快掌握Java技术


       
        
          
            热门标签
            
          
           电脑  科技  计算机科学  vr  操作  云计算  网站建设  微信公众平台  通信  微信公众号  全景拍摄  计算机系统结构  网络工程师  服务器类型  移动端  计算机网络技术  服务器端口  喜茶  系统学习  计算机端口  cdn加速  全景照片  注册公司  数据通信  布局流畅  用户界面  股东  载体  电子技术  课件 
        
        
          
            推荐阅读
            
          
          
            
                              
                
                  长沙软件开发培训-长沙计算机软件开发培训学校好不好？零基础学计算机，千万不要选短期
                  2023-06-19
                
                 
                              
                
                  百元建站-企业官方网站建设还是外包给专业公司比较好的费用
                  2023-06-19
                
                 
                              
                
                  制作图标+软件-Chartistic图标制作免费版是一款十分好用的图表工具
                  2023-06-19