咨询热线 ：
028-86922220
×
01
关于我们

公司简介

发展历程

02
服务项目

高端网站建设

微信开发

APP开发

网络营销服务

电商网站定制

生物医药网站建设

外贸网站建设

教育培训网站建设

03
小程序开发

小程序开发

功能应用

客户案例

04
案例展示

网站建设案例

小程序案例

电商平台案例

APP案例

系统平台案例

05
建站动态

网站建设

网站设计

常见问题

小程序

06
联系我们

公司地址

人才招聘

地址：成都市太升南路288号锦天国际A幢1002号

电话：028-86922220

028-86922220

重庆分公司，新征程启航

为企业提供网站建设、域名注册、服务器等服务

Java线程核心机制是什么

这篇文章主要介绍“Java线程核心机制是什么”，在日常操作中，相信很多人在Java线程核心机制是什么问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”Java线程核心机制是什么”的疑惑有所帮助！接下来，请跟着小编一起来学习吧！

成都创新互联坚持“要么做到，要么别承诺”的工作理念，服务领域包括：成都网站建设、网站制作、企业官网、英文网站、手机端网站、网站推广等服务，满足客户于互联网时代的汪清网站设计、移动媒体设计的需求，帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴！

一、线程基本机制

1、概念描述

并发编程的特点是：可以将程序划分为多个分离且独立运行的任务，通过线程来驱动这些独立的任务执行，从而提升整体的效率。下面提供一个基础的演示案例。

2、应用案例

场景：假设有一个容器集合，需要拿出容器中的每个元素，进行加工处理，一般情况下直接遍历就好，如果数据偏大，可以根据线程数量对集合切割，每个线程处理一部分数据，这样处理时间就会减少很多。

public class ExtendThread01 {
    public static void main(String[] args) {
        List dataList = new ArrayList<>() ;
        dataList.add("A");
        dataList.add("B");
        dataList.add("C");
        // 把一个大的集合按照每个子集合的2个元素切割
        List> splitList = splitList(dataList,2);
        for (List list:splitList){
            System.out.println(list);
        }
        // 多线程处理
        for (List childList:splitList){
            ListTask listTask = new ListTask(childList) ;
            Thread runThread = new Thread(listTask);
            runThread.start();
        }
    }
    /**
     * List 集合切割
     */
    private static List> splitList (List list, int childSize) {
        if (list == null || list.size() == 0 || childSize < 1) {
            return null;
        }
        List> result = new ArrayList<>();
        int size = list.size();
        int count = (size + childSize - 1) / childSize ;
        for (int i = 0; i < count; i++) {
            List subList = list.subList(i * childSize, ((i + 1) * childSize > size ? size : childSize * (i + 1)));
            result.add(subList);
        }
        return result;
    }
}
class ListTask implements Runnable {
    private List list ;
    public ListTask (List list){this.list=list;}
    @Override
    public void run() {
        for (Object object:list){
            System.out.println(Thread.currentThread().getName()+"=="+object);
        }
    }
}
注意：这里案例只是对场景原理的实现，在开发中，是不允许这种操作的，需要使用线程池处理，后续会说。如果集合没有控制好，导致大量创建Thread线程，导致内存溢出。
二、线程停止启动
1、基础流程
线程启动后执行任务方法，在执行过程中可以被阻塞，休眠，唤醒，停止等一系列状态操作。
线程休眠作用：当线程一部分任务执行完毕后进入休眠（阻塞）状态，线程调度器可以切换到另外线程，这对分布任务的执行相对公平。
2、使用案例
public class ExtendThread02 {
    public static void main(String[] args) {
        StopThread stopThread = new StopThread() ;
        stopThread.start();
        // 标记当前线程停止信号，且抛出中断异常，但没有停止
        stopThread.interrupt();
        // 判断当前线程是否已经是终止状态
        System.out.println("1=="+stopThread.isInterrupted());
        // 清除当前线程的终止信号
        System.out.println("2=="+stopThread.interrupted());
        // 再次判断当前线程状态
        System.out.println("3=="+stopThread.isInterrupted());
        System.out.println("main end ...");
    }
}
class StopThread extends Thread {
    @Override
    public void run() {
        for (int i = 0 ; i < 10 ; i++){
            try {
                System.out.println(Thread.currentThread().getId()+"="+i);
                // 线程阻塞1秒
                Thread.sleep(1000);
            } catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}
3、核心方法
sleep(long millis)：线程休眠指定的时间，进入阻塞状态；
interrupt()：切换线程为中断状态，抛出中断异常，不会停止线程，可以监视线程的中断状态并定义执行策略。
interrupted()：清除调用该方法线程的中断状态，也不会影响线程的执行，且返回当前执行‘stopThread.interrupted()’的线程是否中断，这里就是指main线程是否中断。
isInterrupted()：判断调用该方法的线程是否已经是中断状态。
补刀一句：线程的这几个方法极其容易混淆，需要断点源码追踪一下看看，进入源码方法，调用相关API查看一下状态。(附断点图一张：)
Java线程核心机制是什么
三、线程优先级
1、基础概念
CPU执行和处理线程的顺序是不确定的，但是线程调度器倾向执行线程优先级高的线程，线程优先级高说明获取CPU资源的概率高，或者获取的执行时间分片多，但不代表优先级低的一定最后执行。
2、使用案例
public class ExtendThread03 {
    public static void main(String[] args) {
        Priority01 priority01 = new Priority01();
        priority01.start();
        System.out.println("priority01="+priority01.getPriority());
        Priority02 priority02 = new Priority02();
        priority02.start();
        System.out.println("priority02="+priority02.getPriority());
        priority01.setPriority(10);
        priority02.setPriority(1);
    }
}
class Priority01 extends Thread {
    @Override
    public void run() {
        for (int i = 0 ; i < 100 ; i++){
            System.out.println(Thread.currentThread().getName()+";i="+i);
        }
    }
}
class Priority02 extends Thread {
    @Override
    public void run() {
        for (int a = 0 ; a < 100 ; a++){
            System.out.println(Thread.currentThread().getName()+";a="+a);
        }
    }
}
注意：优先级范围[MAX_PRIORITY=10，MIN_PRIORITY=1],如果超出范围会抛出IllegalArgumentException异常。
建议：通常实际开发中，是不允许轻易修改线程运行的参数，容易引发认知之外的异常。
四、线程加入
1、基本概念
如果在线程A中，执行线程B的加入方法，那么A线程就会等待线程B执行完毕再返回继续执行。
2、使用案例
public class ExtendThread04 {
    public static void main(String[] args) {
        JoinThreadA joinThreadA = new JoinThreadA() ;
        joinThreadA.start();
    }
}
class JoinThreadA extends Thread {
    @Override
    public void run() {
        System.out.println("缺水中...");
        JoinThreadB joinThreadB = new JoinThreadB() ;
        joinThreadB.start();
        try{
            joinThreadB.join();
        } catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("喝水中...");
    }
}
class JoinThreadB extends Thread {
    @Override
    public void run() {
        System.out.println("买水中...");
        try{
            TimeUnit.SECONDS.sleep(2);
        } catch (Exception e){
            e.printStackTrace();
        }
        System.out.println("买到水...");
    }
}
注意：可以设置线程的加入时间join(long)，毕竟等不到雪月风花,人生都是有时差，只能后会无期了。
五、本地线程
1、基本概念
本地的线程变量，底层维护ThreadLocalMap存储值：
static class Entry extends WeakReference> {
    Object value;
    Entry(ThreadLocal k, Object v) {
        super(k);
        value = v;
    }
}
即以Key-Value键值对的方式存储数据。如果对集合容器的源码熟悉的话，这个Entry就是似曾相识感觉。
2、使用案例
public class ExtendThread05 {
    private static final ThreadLocal threadLocal = new ThreadLocal<>() ;
    private static void initBegin (){
        threadLocal.set(System.currentTimeMillis());
    }
    private static Long overTime (){
        return System.currentTimeMillis()-threadLocal.get();
    }
    public static void main(String[] args) throws Exception {
        ExtendThread05.initBegin();
        TimeUnit.SECONDS.sleep(3);
        System.out.println(ExtendThread05.overTime());
    }
}
ThreadLocal提供线程内存储变量的能力，并且绑定到当前线程，通过get和set方法就可以得到和设置当前线程对应的值。这个在web开发中是常见的应用。
六、守护线程
1、基本概念
守护线程是支持辅助型线程，主要在程序中起到调度和支持性作用，当Jvm中非守护线程全部结束，守护线程也就会结束。
2、使用案例
public class ExtendThread06 {
    public static void main(String[] args) throws Exception {
        InputStreamReader is = new InputStreamReader(System.in);
        BufferedReader br = new BufferedReader(is);
        String value = br.readLine();
        CheckThread checkThread = new CheckThread(value) ;
        checkThread.setDaemon(true);
        checkThread.start();
        System.out.println("Main End ...");
    }
}
class CheckThread extends Thread {
    private String spell ;
    public CheckThread (String spell){
        this.spell = spell ;
    }
    @Override
    public void run() {
        if (spell.startsWith("cs")){
            System.out.println(spell+"：输入正确");
        } else {
            System.out.println(spell+"：输入错误");
        }
        try {
            TimeUnit.SECONDS.sleep(10);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
注意：守护线程需要显式调用setDaemon(true);方法，这里可以看到main线程结束，整合程序就结束了，丝毫理会休眠中的守护线程。如果打断非守护线程的休眠，试试会不会抛你一脸异常？
七、线程异常处理
1、机制描述
按照Java中异常处理机制，抛异常逐级降低，线程的任务方法run没有抛异常，那重写或者实现的方法自然不能直接throws异常出去。多线程中推荐捕获异常，可以针对性处理机制。
2、使用案例
public class ExtendThread07 {
    public static void main(String[] args) {
        TryThread tryThread = new TryThread();
        tryThread.setName("try-name");
        // 定义运行中异常处理策略
        MyExe myExe = new MyExe() ;
        tryThread.setUncaughtExceptionHandler(myExe);
        tryThread.start();
    }
}
class TryThread extends Thread {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        // 如何处理这里异常？
        Integer.parseInt("cicada") ;
    }
}
class MyExe implements Thread.UncaughtExceptionHandler {
    @Override
    public void uncaughtException(Thread t, Throwable e) {
        System.out.println(t.getName()+"；异常："+e.getMessage());
    }
}
通过实现UncaughtExceptionHandler接口，并且线程要指定自定义异常处理对象，也可以处理未检查的异常。
到此，关于“Java线程核心机制是什么”的学习就结束了，希望能够解决大家的疑惑。理论与实践的搭配能更好的帮助大家学习，快去试试吧！若想继续学习更多相关知识，请继续关注创新互联网站，小编会继续努力为大家带来更多实用的文章！
            
            
                        

            网站题目：Java线程核心机制是什么            

            当前URL：http://cqcxhl.com/article/pgcdih.html
        
    
    

        
其他资讯

        
    




    

        

            

                

                

                    
分享至：

                    

                        
                        
                        
                        
                    

                    
                

            

            

                

                    
关于我们

                    

                        公司简介
                        发展历程
                    

                

                

                    
服务项目

                    

                        高端网站建设
                        小程序开发
                        APP开发
                        网络营销
                    

                

                

                    
建站知识

                    

                        网站建设
                        网站设计
                        网站制作
                        小程序
                    

                

                

                    
联系我们

                    

                        公司地址
                        人才招聘
                    

                

            

            

                

                    成都
                    重庆
                

                

                    

                        

                            

                            
电话：028-86922220

                        

                        

                            

                            
地址：成都市太升南路288号锦天国际A幢1002号

                        

                    

                    

                        

                            

                            
电话：028-86922220

                        

                        

                            

                            
地址：重庆市南岸区弹子石腾龙大道58号2栋21-6

                        

                    

                

            

        

    

    
版权所有：成都创新互联科技有限公司重庆分公司
        渝ICP备2021005571号-4
    







    
        

            

            
在线咨询

        

    
    
        

            

            
服务热线

        

        
服务热线：028-86922220

    
    
        

            

            
TOP