三.java线程

于 2022-04-16 12:32:36 发布
阅读量117 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_31511385/article/details/124193609
版权

1.创建线程

(1).直接使用Thread

示例

package com.xiaotian.demo01;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Demo01 {
    public static void main(String[] args) {
        //创建线程对象
        Thread t = new Thread(){
            @Override
            public void run() {
                log.info("t线程");
            }
        };
        //启动线程
        t.start();
        log.info("main线程");
    }
}

执行结果

在这里插入图片描述

(2).使用Runnable接口(推荐)

示例

Runnable task = new Runnable() {
    public void run() {
        log.info("t线程");
    }
};
Thread t = new Thread(task, "t1");
t.start();
log.info("main线程");

使用lambda简化

在这里插入图片描述
其中@FunctionalInterface表示接口只有一个方法

Runnable task = () -> log.info("t1.线程");
Thread t = new Thread(task, "t1");
t.start();
log.info("main线程");

执行结果

在这里插入图片描述

*Thread与Runnable的关系

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

小结

[1].方法1把线程和任务合并在了一起，方法2是把线程和任务分开了

[2].用Runnable更容易与线程池等高级API配合

[3].用Runnable让任务类脱离了Thread继承体系，更灵活

(3).使用FutureTask类

示例

  FutureTask<Integer> task = new FutureTask<>(()->{
             log.info("task");
             return 100;
        });
        new Thread( task, "t1").start();
        Integer result = task.get();
        log.debug("结果是:{}", result);

执行结果

在这里插入图片描述

2.查看线程

(1).windows

[1].任务管理器可以查看进程和线程数，也可以用来杀死进程
[2].tasklist查看线程

tasklist | findstr java

[3].taskkill杀死线程

taskkill /f /pid 28060

(2).Linux

[1].ps -fe 查看所有进程

 ps -ef|grep java

[2].ps -fT -p 查看某个进程(PID)的所有线程

[3].kill杀死进程

[4].top按大写H切换是否显示线程

[5].top -H -p 查看某个进程的所有线程

(3).Java

[1].jps命令查看所有Java进程
[2].jstack 查看某个Java进程(PID)的所有线程状态
[3].jconsole来查看某个Java进程中线程运行情况

*原理之线程运行

(1).栈与栈帧

Java Virtual Machine Stacks(Java虚拟机栈)

我们知道JVM中由堆，栈，方法区所组成，其中栈内存是是给谁用的呢？其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。

[1].每个栈由多个栈帧(Frame)组成，对应着每次方法调用所占用的内存

[2].每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

(2).栈帧图解

package com.xiaotian.demo01;

public class TestFrames {
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                method1(10);
            }
        };
        t1.setName("t1");
        System.out.println(t1.getState());
        t1.start();
        t1.start();
        System.out.println(t1.getState());
        method1(20);

    }

    private static void method1(int x){
        int y = x + 1;
        Object m = method2();
        System.out.println(m);
    }

    private static Object method2(){
        Object n = new Object();
        return n;
    }
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

(3).多线程的idea调试

[1].选择调试模式
在这里插入图片描述
使用鼠标右击断点，出来如图所示，选择Thread
[2].进行断点调试
在这里插入图片描述
可以在如上图所示选择栈帧

(4).线程上下文切换(Thread Context Switch)

因为一下一些原因导致cpu不再执行当前线程，转而执行另一个线程的代码
[1].线程的cpu时间片用完

[2].垃圾回收

[3].有更高优先级的线程需要运行

[4].线程自己调用了sleep, yield, wait, join, park, synchronized, lock等方法

当Context Switch发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java中对应的概念就是程序计数器(Program Counter Register), 它的作用是记录下一条jvm指令的执行地址，是线程私有的

[1].状态包括程序计数器，虚拟机栈中每个栈帧的信息，如局部变量，操作数栈，返回地址等。

[2].Context Switch频繁发生影响性能

3.线程API

(1).API概览

方法名static功能说明注意
start()启动一个新线程，在新的线程运行run方法中的代码start方法只是让线程进入就绪，里面代码不一定立刻运行(CPU的时间片还分给它)。每个线程对象的start方法只能调用一次，如果调用了多次会出现IllegalThreadStateException
run()新线程启动后调用的方法如果在构造Thread对象时传递了Runnable参数，则线程启动后会调用Runnable中的run方法，否则默认不执行任何操作，但可以创建Thread的子类对象，来覆盖默认方法
join()等待线程运行结束
join(long n)等待线程运行结束，最多等待n毫秒
getId()获取线程长整数的，id:唯一idid唯一
getName()获取线程名
setName(String)修改线程名
getPrority()获取线程优先级
setPrority(int)修改线程优先级java中规定线程优先级是1~10的整数，较大的优先级提高该线程被CPU调度的几率
getState()获取线程状态Java中线程状态是用6个enum表示, 分别为:NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
isInterrupted()判断线程是否被打断不会清楚打断标记
interrupt()打断线程如果被打断线程正在sleep, wait, join会导致被打断的线程抛出InterruptedException, 并清除打断标记；如果打断的正在运行的线程，则会设置打断标记，park的线程被打断，也会设置打断标记
interrupted()static判断当前线程是否被打断会清除打断标记
currentThread()static获取当前正在执行的线程
sleep(long n)static让当前执行的线程休眠n毫秒，休眠时让出cpu的时间片给其他线程
yield()static提示线程调度器让出当前线程对CPU的使用主要是为了测试和调试isAlive()线程是否存活(还没有运行完毕)

(2).start和run方法

[1].start方法执行前后的线程状态

示例
Thread t1 = new Thread(){
    @Override
    public void run() {
        method1(10);
    }
};
t1.setName("t1");
System.out.println(t1.getState());
t1.start();
System.out.println(t1.getState());
执行结果

在这里插入图片描述

[2].多次调用start()方法

示例
Thread t1 = new Thread(){
    @Override
    public void run() {
        method1(10);
    }
};
t1.setName("t1");
System.out.println(t1.getState());
t1.start();
t1.start();
System.out.println(t1.getState());
执行结果

在这里插入图片描述

(3).sleep与yield

[1].sleep

[a]. 调用sleep会让当前线程从Running进入Timed Waiting状态

示例:

Thread t1 = new Thread("t1"){
    @Override
    public void run() {
        try
        {
            Thread.sleep(2000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
};
t1.start();
log.debug("t1 state:{}", t1.getState());
Thread.sleep(500);
log.debug("t1 state:{}", t1.getState());

执行结果:
在这里插入图片描述

[b].其他线程可以使用interrupt方法打断正在睡眠的线程，这时sleep方法会抛出InterruptedException

示例

Thread t1 = new Thread("t1"){
    @Override
    public void run() {
       log.debug("enter sleep...");
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            log.debug("wake up...");
            e.printStackTrace();
        }
    }
};
t1.start();
Thread.sleep(1000);
log.debug("interrupt...");
t1.interrupt();

执行结果:
在这里插入图片描述

[c].睡眠结束后的线程未必会立刻得到执行
[d].建议使用TimeUnit的sleep代替Thread的sleep来获得更好的可读性

示例

TimeUnit.SECONDS.sleep(1);

[2].yield

[a].调用yield会让当前线程从Running进入Runnable状态，然后调度执行其他同优先级的线程。如果这时没有同优先级的线程，那么不能保证让当前线程暂停的效果

[b].具体的实现依赖于操作系统的任

[3].sleep方法应用

在没有利用cpu来计算时，不要让while(true)空转浪费cpu，这时可以使用yied或sleep来让出cpu的使用权给其他程序

while(true){
    Thread.sleep(50);
}

[a].可以使用wait或条件达到类似的效果

[b].不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景

[c].sleep适用于无需锁同步的场景

(4).线程优先级

线程优先级会提示(hint)调度器优先调度该线程，但它仅仅是一个提示，调度器可以忽略它
如果cpu比较忙，那么优先级的线程会获得更多的时间片，但cpu闲时，优先级几乎没作用

示例

Runnable task1 = () -> {
  int count = 0;
  for(;;){
      System.out.println("1---->" + count++);
  }
};
Runnable task2 = () -> {
    int count = 0;
    for(;;){
        Thread.yield();
        System.out.println("         2---->" + count++);
    }
};
Thread t1 = new Thread(task1, "t1");
Thread t2 = new Thread(task2, "t2");
t1.setPriority(Thread.MIN_PRIORITY);
t2.setPriority(Thread.MAX_PRIORITY);
t1.start();
t2.start();

执行结果

在这里插入图片描述

(5).join方法

[1].示例

问题

想让r的结果打印为10

static int r = 0;

private static void test1(){
    log.debug("start...");
    Thread t1 = new Thread(()->{
      log.debug("start...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("end...");
        r = 10;
    }, "t1");
    t1.start();
    log.debug("结果为{}", r);
    log.debug("end..");
}



public static void main(String[] args) {
      test1();
}

但是执行结果都为0

分析

[a].因为主线程和线程t1是并行执行的，t1线程需要1s之后才能算出r=10

[b].而主线程一开始就要打印r的结果，所以只能打印出r=0

解决方法
static int r = 0;

private static void test1() throws InterruptedException {
    log.debug("start..");
    Thread t1 = new Thread(()->{
      log.debug("start...");
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("end...");
        r = 10;
    }, "t1");
    t1.start();
    t1.join();
    log.debug("结果为{}", r);
    log.debug("end..");
}



public static void main(String[] args) throws InterruptedException {
      test1();
}

[2].同步应用

以调用方角度来讲，如果

[a].需要等待结果返回，才能继续运行就是同步

[b].不需要等待结果返回，就能继续运行就是异步

示例

static int r = 0;
static int r1 = 0;
static int r2 = 0;

public static void main(String[] args) throws InterruptedException {
    test2();
}

private static void test2() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        r1 = 10;
    });
    Thread t2 = new Thread(() -> {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        r2 = 20;
    });
    long start = System.currentTimeMillis();
    t1.start();
    t2.start();
    log.debug("join begin");
    t1.join();
    log.debug("t1 join end");
    t2.join();
    log.debug("t2 join end");
    long end = System.currentTimeMillis();
    log.debug("r1:{}, r2:{}, cost:{}", r1, r2, end-start);

执行结果
在这里插入图片描述
分析
在这里插入图片描述

[3].限时同步

下面执行得到r1的结果为0

Thread t1 = new Thread(() -> {
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    r1 = 10;
});

long start = System.currentTimeMillis();
t1.start();
t1.join(1500);
long end = System.currentTimeMillis();
log.debug("r1:{}, r2:{}, cost:{}", r1, r2, end-start);

(6).interrupt方法

[1].打断阻塞

打断sleep, wait, join的线程

以sleep为例

public static void main(String[] args) {
     test1();
}

private static void test1() {
    Thread t1 = new Thread(()->{
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }, "t1");
    t1.start();
    try {
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    t1.interrupt();
    log.debug("打断状态:{}", t1.isInterrupted());
}

执行结果
在这里插入图片描述

[2].打断正常

示例

public static void main(String[] args) throws InterruptedException {
    test2();
}

private static void test2() throws InterruptedException {
    Thread t2 = new Thread(()->{
        while(true){
            Thread current = Thread.currentThread();
            boolean interrupted = current.isInterrupted();
            if(interrupted){
                log.debug("打断状态:{}", interrupted);
                break;
            }
        }
    }, "t2");
    t2.start();
    Thread.sleep(500);
    t2.interrupt();
}

执行结果:
在这里插入图片描述

[3].两阶段终止模式

问题

在一个线程T1中如何"优雅"终止线程T2? 这里的[优雅]指的是给T2一个料理后事的机会

[a].错误思路

[a1].使用线程对象的stop()方法停止线程

stop方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁，其他线程永远无法获取锁

[a2].使用System.exit(int)方法停止线程

目的仅是停止一个线程，但这种做法会让整个程序都停止。

[b].分析

在这里插入图片描述

[c].实现
package com.xiaotian.demo01;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class TwoPhaseTermination {

    private Thread monitor;

    /**
     * 启动监控线程
     */
    public void start(){
        monitor = new Thread(()->{
           while(true){
               Thread current = Thread.currentThread();
               if(current.isInterrupted()){
                   log.debug("料理后事");
                   break;
               }
               try {
                   log.debug("执行监控");
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   current.interrupt(); //重新设置标志
                   e.printStackTrace();
               }
           }
        });
        monitor.start();
    }

    /**
     * 停止监控线程
     */
    public void stop(){
        monitor.interrupt();
    }
}

调用:

TwoPhaseTermination twoPhaseTermination = new TwoPhaseTermination();
twoPhaseTermination.start();
Thread.sleep(3000);
twoPhaseTermination.stop();

执行结果
在这里插入图片描述

(7).park方法

[1].示例

Thread t1 = new Thread(()->{
   log.debug("park...");
    LockSupport.park();
    log.debug("unpark...");
    log.debug("打断状态:{}", Thread.currentThread().isInterrupted());
}, "t1");
t1.start();
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
t1.interrupt();

[2].执行结果
在这里插入图片描述

(8).过时方法(不推荐使用)

方法名static功能说明
stop()停止线程运行
suspend()挂起(暂停)线程运行
resume()恢复线程运行

(9).守护线程

默认情况下，Java进程需要等待所有线程都运行结束，才会借宿。有一种特殊的线程叫做守护线程，只要其他非守护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。
示例

log.debug("开始运行...");
Thread t1 = new Thread(() -> {
    log.debug("开始运行..");
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    log.debug("运行结束..");
}, "deamon");
//设置该线程为守护线程
t1.setDaemon(true);
t1.start();
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
log.debug("运行结束...");

执行结果:
在这里插入图片描述
注意:
[1].垃圾回收期线程就是一种守护线程

[2].Tomcat中的Acceptor和Poller线程都是守护线程，所以Tomcat接收到shutdown命令后，不会等待他们处理完当前请求

4.线程状态

(1).五种状态(从操作系统)

在这里插入图片描述
[1].初始状态:仅是在语言层面创建了线程对象，还未与操作系统线程关联

[2].可运行状态:指该线程已经被创建(与操作系统线程关联)，可以由CPU调度执行(就绪状态)

[3].运行状态: 指获取了CPU时间片运行中的状态

当CPU时间片用完，会从运行状态切换至可运行状态，会导致线程的上下文切换

[4].阻塞状态:

​ 如果调用了阻塞API,如BIO读写文件，这时线程实际不会用到CPU, 会导致线程上下文切换，进程进入阻塞状态

​ 等BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至可运行状态

与可运行状态的区别是, 对阻塞状态的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们

[5].终止状态:表示线程已经执行完毕，生命周期已经结束，不会再转为其他状态

(2).六种状态(Java API层面)

在这里插入图片描述
(1).NEW线程刚被创建，但是还没有调用start()方法

(2).RUNNABLE当调用了start()方法之后，注意, Java API层面的RUNNABLE状态涵盖了操作系统层面可运行状态，运行状态和阻塞状态(由于BIO导致的线程阻塞，在Java里无法区分，任然认为是可运行)

(3).BLOCKED, WAITING, TIMED_WAITING都是Java API层面对阻塞状态的细分

(4).TERMINATED当线程代码运行结束

(3).使用java演示六种状态

示例

package com.xiaotian.demo01;

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class Demo13 {
    public static void main(String[] args) {
        Thread t1 = new Thread("t1"){
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        Thread t2 = new Thread("t2"){
            @Override
            public void run() {
                while(true){

                }
            }
        };
        t2.start();
        Thread t3 = new Thread("t3"){
            @Override
            public void run() {
                log.debug("running");
            }
        };
        t3.start();
        Thread t4 = new Thread("t4"){
            @Override
            public void run() {
                synchronized (Demo13.class){
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();
        Thread t5 = new Thread("t5"){
            @Override
            public void run() {
                try {
                    t2.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();
        Thread t6 = new Thread("t6"){
            @Override
            public void run() {
                synchronized (Demo13.class){
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        log.debug("t1 state {}", t1.getState());
        log.debug("t2 state {}", t2.getState());
        log.debug("t3 state {}", t3.getState());
        log.debug("t4 state {}", t4.getState());
        log.debug("t5 state {}", t5.getState());
        log.debug("t6 state {}", t6.getState());

    }
}

执行结果:
在这里插入图片描述

5.线程案例-统筹

阅读华罗庚《统筹方法》，给出烧水泡茶的多线程解决方法，提示

参考下图2，用两个线程(两个人协作)模拟烧水泡茶过程

​ 文中办法乙，丙都相当于任务串行

​ 而图1相当于启动了4个线程，浪费

用sleep(n)模拟洗茶壶，洗水壶等消耗的时间

附: 华罗庚《统筹方法》

统筹方法，是一种安排工作进程的数学方法。它的实用范围极广泛，在企业管理和基本建设中，以及关系复杂的科研项目的组织与管理中，都可以应用。

怎样应用呢？主要是把工序安排好。

比如，想泡壶茶喝。当时的情况是：开水没有；水壶要洗，茶壶、茶杯要洗；火已生了，茶叶也有了。怎么办？

  办法甲：洗好水壶，灌上凉水，放在火上；在等待水开的时间里，洗茶壶、洗茶杯、拿茶叶；等水开了，泡茶喝。
  办法乙：先做好一些准备工作，洗水壶，洗茶壶茶杯，拿茶叶；一切就绪，灌水烧水；坐待水开了，泡茶喝。
  办法丙：洗净水壶，灌上凉水，放在火上，坐待水开；水开了之后，急急忙忙找茶叶，洗茶壶茶杯，泡茶喝。
  
哪一种办法省时间？我们能一眼看出，第一种办法好，后两种办法都窝了工。
这是小事，但这是引子，可以引出生产管理等方面有用的方法来。
水壶不洗，不能烧开水，因而洗水壶是烧开水的前提。没开水、没茶叶、不洗茶壶茶杯，就不能泡茶，因而这些又是泡茶的前提。它们的相互关系，可以用下边的箭头图来表示:

在这里插入图片描述

从这个图上可以一眼看出，办法甲总共要16分钟（而办法乙、丙需要20分钟）。如果要缩短工时、提高工作效率，应当主要抓烧开水这个环节，而不是抓拿茶叶等环节。同时，洗茶壶茶杯、拿茶叶总共不过4分钟，大可利用“等水开”的时间来做。
是的，这好像是废话，卑之无甚高论。有如走路要用两条腿走，吃饭要一口一口吃，这些道理谁都懂得。但稍有变化，临事而迷的情况，常常是存在的。在近代工业的错综复杂的工艺过程中，往往就不是像泡茶喝这么简单了。任务多了，几百几千，甚至有好几万个任务。关系多了，错综复杂，千头万绪，往往出现“万事俱备，只欠东风”的情况。由于一两个零件没完成，耽误了一台复杂机器的出厂时间。或往往因为抓的不是关键，连夜三班，急急忙忙，完成这一环节之后，还得等待旁的环节才能装配。洗茶壶，洗茶杯，拿茶叶，或先或后，关系不大，而且同是一个人的活儿，因而可以合并成为：

在这里插入图片描述

看来这是“小题大做”，但在工作环节太多的时候，这样做就非常必要了。
这里讲的主要是时间方面的事，但在具体生产实践中，还有其他方面的许多事。这种方法虽然不一定能直接解决所有问题，但是，我们利用这种方法来考虑问题，也是不无裨益的

实现:

   Thread t1 = new Thread(()->{

            try {
                log.info("洗水壶开始");
                Thread.sleep(1000);//洗水壶
                log.info("洗水壶结束");
                log.info("烧开水开始");
                Thread.sleep(15000);//烧开水
                log.info("烧开水结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

        }, "t1");
        Thread t2 = new Thread(()->{
            try {
                log.info("洗茶壶，洗茶杯，拿茶叶开始");
                Thread.sleep(4000);
                log.info("洗茶壶，洗茶杯，拿茶叶结束");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }, "t2");
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        log.info("喝茶");
qq_31511385
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
小球线程动画 .java
12-20
java 线程 动画
IDEA 多线程debug调试
浮生小二的博客
06-12 1218
文章目录IDEA 多线程debug调试1、设置IDEA的中断方式为线程2、设置文件锁3、线程类4、打断点4、启动线程5、进入线程断点6、断点调试 IDEA 多线程debug调试 多线程修改同一个文件作为演示 1、设置IDEA的中断方式为线程 2、设置文件锁 import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.nio.channels.FileChannel; import
Idea：多线程调试，以及进入线程的run或者call方法
琦彦
04-28 1万+
IDEA：Debug使用详解（含2018版特性） Idea，debug的基本使用，请参考：https://blog.csdn.net/fly910905/article/details/80013391 Idea：多线程调试设置 1. 在断点上右键 2. 选择Thread,然后点Done(建议选择Thread后点击make default把此模式设置为默认模式 3. 开启...
Idea Intellij多线程调试
热门推荐
fuzzytalker的专栏
03-18 5万+
（适用Idea 14 & 15，其他版本未知）几天前遇到一个问题： 在多线程调试的时候，一些断点会被跳过。比如像下面的代码：public static void main(String[] args) throws InterruptedException { new Thread() { // 断点0 @Override public void run()
IDEA 单步调试多线程
m0_38129920的博客
02-16 2292
不得不说，IDEA是真的强大。 告别打日志的方法吧，直接使用IDEA进行多线程的调试。 多线程单步调试步骤： 1.首先在你需要单步调试的地方打上断点，然后鼠标右键已经打好的断点，可以跳出断点的设置。 2.断点默认Suspend的选项是All，这里改成Thread模式，然后点击more更多设置   勾选上Log选项的两项，这样在跳到断点时IDEA在左下角会给我们一点小提示，提示swi...
java多线程案例_java多线程经典案例
weixin_39613208的博客
02-12 66
/*** 典型案例：子线程执行10次，主线程执行100次，两者交替50次。*/package cn.itcast.lesson4;public class TestWaitNotify {public static void main(String[] args){final Business business= new Business();new Thread(new Runnable() {...
Java线程安全.docx
10-24
Java线程安全
java线程分析工具TDA
06-21
分析java线程日志的工具，使用jstack把java线程日志dump下来，然后上传到该工具，就可以查看线程阻塞情况等信息。
java多线程.xmind
07-05
java线程操作知识点，使用xmind8思维导图进行编写的，需使用xmind打开
Java与线程.pdf
最新发布
04-19
Java线程的实现主要采用1：1的线程模型，即每个Java线程直接映射到一个操作系统原生线程。这种模型在主流平台上的主流商用Java虚拟机中普遍使用。以HotSpot为例，它的每一个Java线程都直接映射到一个操作系统原生...
Linux下查看消耗CPU的线程 占用 100% java jvm 堆栈
fei33423的专栏
04-09 613
javaweb 项目部署后发现很耗cpu，需要查出问题所在 写个测试程序，记相关步骤： 故意写个死循环 public class TestCpu { public static void main(String[] args) { while (true){ new Object(); } } } 终端： top...
linux jni 多线程,JNI多线程
weixin_32334209的博客
05-10 166
JavaVM 代表的是Java虚拟机，所有的工作都是从JavaVM开始可以通过JavaVM获取到每个线程关联的JNIEnv如何获取JavaVM？在JNI_OnLoad函数中获取(*env)->GetJavaVM(env,&javaVM);JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved){LOGI("%s","JNI_OnLoa...
java线程条件变量_Linux多线程编程-条件变量
weixin_32836713的博客
02-26 78
条件变量如果说线程间的互斥锁是用来同步共享数据的访问的话，那么条件变量是用于线程之间共享数据的值。条件变量提供了一种线程之间的通知机制，当某个共享数据达到某个值时，唤醒等待这个共享数据的线程。条件变量相关函数主要 有5个：#include int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *cond_attr)...
linux下java多线程_Java多线程基本使用
weixin_39955829的博客
02-13 397
一．概念1.进程1.1进程：是一个正在进行中的程序，每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。1.2线程：就是进程中一个独立的控制单元，线程在控制着进程的执行，一个进程中至少有一个线程。1.3举例Java VM：Java VM启动的时候会有一个进程java.exe,该进程中至少有一个线程在负责java程序的运行，而且这个线程运行的代码存在于main方法中，该线程称之...
Java线程和操作系统线程的关系
wzl1217333452的博客
06-30 2771
传统进程的缺点 fork一个子进程的消耗是很大的，fork是一个昂贵的系统调用，即使使用现代的写时复制(copy-on-write)技术。 各个进程拥有自己独立的地址空间，进程间的协作需要复杂的IPC技术，如消息传递和共享内存等。 多线程的优缺点 线程：其实可以先简单理解成cpu的一个执行流，指令序列。多支持多线程的程序(进程)可以取得真正的并行(parallelism)，且由于共享进程的代码和全局数据，故线程间的通信是方便的。它的缺点也是由于线程共享进程的地址空间，因此可能会导致竞争，因此对某一块有多
linux下java多线程_关于Linux下的多线程
weixin_39603995的博客
02-17 198
#include #include void printThread(const char *s){pid_t pid;pthread_t tid;pid = getpid();tid = pthread_self();printf("%s pid %u tid %u (0x%x)\n", s, (unsigned int) pid, (unsigned int) tid, (unsigned i...
Linux多线程同步
hzy694358的专栏
01-04 659
1 互斥锁 　　互斥锁用来保证一段时间内只有一个线程在执行一段代码。必要性显而易见：假设各个线程向同一个文件顺序写入数据，最后得到的结果一定是灾难性的。 　　先看下面一段代码。这是一个读/写程序，它们公用一个缓冲区，并且假定一个缓冲区只能保存一条信息。即缓冲区只有两个状态：有信息或没有信息。 void reader_function ( void ); void writer_func
linux 线程池的线程无法执行调用到定义好的任务方法,JAVA多线程实际应用中的示例...
weixin_39901412的博客
05-08 187
多线程一直是java应用中最容易出现瓶颈问题的地方；多线程代码的好坏，往往会导致程序在性能上出现较大的差别，No Speaking much,show your guys code~1、线程池异步调用，处理大批量数据的分批发送问题解决思路是：数据入临时表，rownum做主键，启动线程池，分批次发送数据阿里巴巴开发手册(泰山版)对线程池的使用，有着以下的介绍：线程池不允许使用 Executors 去...
.java的线程锁有哪些
06-11
Java 中的线程锁主要可以分为以下几种： 1. synchronized：synchronized 是 Java 中最基本的线程锁，它是一种悲观锁，即假设会发生并发访问而导致数据不一致，因此需要加锁来保证同一时刻只有一个线程访问共享资源...

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值