thdqn
thdqn

java多线程

线程六种状态

  1. New:尚未启动的线程的线程状态（new Thread）
  2. Runnable：可运行线程的线程状态，等待cpu调度(调用star)
  3. Blokcked： 线程阻塞等待监视器锁定的线程专状态，处于synchronized同步代码块或方法中被阻塞。
  4. Waiting: 线程等待的线程状态。
    不带timeout参数的方式调用Object.wait, thread.jion, LockSupport.park
  5. Timed Waiting: 具有指定等待时间的等待线程的线程状态，下列超时的方式：Thread.sleep, Object.wait, Thread.join, LockSupport.parkNanos, LockSupport.parkUntil
  6. Terminated: 终止线程的线程状态， 线程正常完成执行或者出现异常
public class ScannerTest {
    public static void main(String[] arg) throws InterruptedException {
        test1();
    };
    
    public static void test1() throws InterruptedException{
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1运行");
            }
        });
        System.out.println("1调用前状态"+ thread1.getState().toString());
        Thread.sleep(1000L);
        thread1.start();
        System.out.println("2调用后状态"+ thread1.getState().toString());
        Thread.sleep(2000L);
        System.out.println("2s后的状态" + thread1.getState().toString());
    }
}

/**
1调用前状态NEW
2调用后状态RUNNABLE
线程1运行
2s后的状态TERMINATED
**/

public static void test2() throws InterruptedException {
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    Thread.sleep(5000L);
                    System.out.println("线程2运行" + Thread.currentThread().getState());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        thread2.start();
        System.out.println("调用后状态：" + thread2.getState().toString());
        Thread.sleep(2000L);
        System.out.println("等待2s后状态:" + thread2.getState().toString());
    }
/*
调用后状态：RUNNABLE
等待2s后状态:TIMED_WAITING
线程2运行RUNNABLE
*/


public static void test3() throws InterruptedException {
        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("抢锁之前状态" + Thread.currentThread().getState());
                synchronized (ThreadTest.class) {
                    System.out.println("拿到锁继续执行" + Thread.currentThread().getState());
                }
            }

        });
        synchronized(ThreadTest.class) {
            thread3.start();
            Thread.sleep(2000L);
            System.out.println("调用等待2s状态" + thread3.getState().toString());
            Thread.sleep(4000L);
            
        }
    }
/*
抢锁之前状态RUNNABLE
调用等待2s状态BLOCKED
拿到锁继续执行RUNNABLE

*/

终止线程

1.过时的stop方法
如果线程里面的程序没有执行完，会被终止点，后面的不在继续执行

public class StopThread {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();
        Thread.sleep(1000);
        thread.stop();
        while(thread.isAlive()) {} // 确保线程被终止了，
        //打印结果
        thread.print();
    }
}

class MyThread extends Thread{
    private int i=0,j=0;
    @Override
    public void run(){
        synchronized(this) {
            ++i;
            try {
                Thread.sleep(5000);
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
            ++j;
        }
        System.out.println("释放");
    }
    public void print() {
        System.out.println("i=" + i + "j="+j);
    }
}

// i=1j=0

2.interrupt终止
把上面代码的thread.stop(); 换成 thread.interrupt();
会报错, 可以看到虽然终止了程序但是后面依然执行了，可以再异常里面做其他处理

java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
释放
    at com.Hello.ScannerTest.MyThread.run(StopThread.java:23)
i=1j=1
  1. 用标志位的方式中断线程
    在线程外面用一个标志来判断线程是否可执行
public class StopTh {
    public volatile static boolean flag = true;
    public static void main(String[] args) throws InterruptedException {
        new Thread(()->{
            try {
                while(flag) {
                    System.out.println("运行");
                    Thread.sleep(1000L);
                }
            }catch(InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        Thread.sleep(3000L);
        flag = false;
        System.out.println("运行结束");
    }
}

/*运行
运行
运行
运行结束
*/

线程封闭

多线程访问共享可变数据时，涉及到线程间数据同步问题
并不是所有时候，都要用到共享数据，若数据都被封闭在各自的线程之中，就不需要同步，这种通过将数据封闭在线程中而避免使用同步的技术称为线程封闭

ThreadLocal

使用ThreadLocal 就算一个线程改变了值，但是对其他线程获取这个值原来的数据 没有任何影响

public class ThreadLocalTest {
    public static ThreadLocal value = new ThreadLocal<>();
    
    public static void main(String[] arg0) {
        new Thread(new Runnable() {
            @Override
            public void run () {
                value.set("11111");
                try {
                    Thread.sleep(1000L);
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(value.get());
            }
        }).start();
        
        new Thread(new Runnable() {
            @Override
            public void run () {
                try {
                    Thread.sleep(1000L);
                    System.out.println(value.get());
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

// 11111
// null

栈封闭

局部变量的固有属性之一就是封闭在线程中
他们位于线程的栈中，其他线程无法访问这个栈

线程池

线程池管理器：用于创建并管理线程池，包括创建线程池，销毁线程池，添加新任务，
工作线程：线程池中线程，可以虚幻的执行任务，在没有任务时处于等待状态；
任务接口：每个任务必须实现的接口，以供工作线程调度任务的执行，他主要规定了任务的入口，任务完成后的收尾工作，任务的执行状态等；
任务队列：用于存放没有处理的任务，提供一种缓冲机制；

线程池类的结构：
接口：Executor 最上层的接口，之定义了execute
接口：ExecutorService 继承了Exexutor ，拓展了Callable,Future,关闭方法；
接口：ScheduledExecutorService 继承ExecutorService，增加了定时任务相关的方法，
实现类：ThreadPoolExecutor 基础，标准的线程池实现
实现类: ScheduledThreadPoolExecutor 继承了ThreadPoolExecutor,实现了ScheduledExecutorService中相关定时任务的方法

Runnale 和Callable 一些区别

public class RunnableTest {
    static ThreadPoolExecutor pool = 
            new ThreadPoolExecutor(1, 2, 5, TimeUnit.SECONDS, new LinkedBlockingQueue());
    public static void main(String args[])throws ExecutionException,InterruptedException {
        Future run_future = pool.submit(new MyRunnable());
        System.err.println("run_future:" + run_future.get());
        Future call_futter =pool.submit(new MyCallable());
        System.err.println("call_future:" + call_futter.get());
    }
}

class MyCallable implements Callable{
    @Override
    public Integer call()throws Exception{
        return 1;
    }
}
class MyRunnable implements Runnable{
    @Override
    public void run() {
        return;
    }
}
/*
run_future:null
call_future:1

*/

ThreadPoolExecutor

public class threadPool {
public static void main(String[] arg) throws Exception {
test();
}
private static void test() throws Exception{
ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
5, //核心线程数，超时不会被清空
10, // 最大线程数10
5, // 保持的时间，超时 没执行的任务被清空
TimeUnit.SECONDS,
new LinkedBlockingQueue(5), // 等待队列容量为5
// 最多容纳15个任务，查出的会被拒绝执行
new RejectedExecutionHandler() {
@Override
public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
System.err.println("有任务被拒绝执行了");

            }
        }
    );
    testCommon(threadPool);
}
public static void testCommon(ThreadPoolExecutor threadPool) throws Exception{
    for(int i=0;i<30; i++) {
        int n = i;
        threadPool.submit(new Runnable() {
            @Override
            public void run () {
                try {
                    System.out.println("任务"+ n +"开始执行");
                    Thread.sleep(3000L);
                    System.out.println("任务"+ n +"执行完成");
                }catch(Exception e) {
                    e.printStackTrace();
                }
            }
        });
        System.out.println("任务" + i + "提交");
    }
    while(true) {
        Thread.sleep(1000);
        System.out.println("》》》线程数量"+threadPool.getPoolSize());
        System.out.println(">>>任务队列" + threadPool.getQueue().size());
    }
}

}

/*

任务0提交
任务0开始执行
任务1提交
任务2提交
任务1开始执行
任务3提交
任务2开始执行
任务4提交
任务5提交
任务6提交
任务7提交
任务3开始执行
任务4开始执行
任务8提交
任务9提交
任务10提交
任务11提交
任务12提交
任务10开始执行
任务13提交
任务11开始执行
任务12开始执行
任务14提交
有任务被拒绝执行了
任务15提交
任务13开始执行
任务16提交
有任务被拒绝执行了
有任务被拒绝执行了
有任务被拒绝执行了
有任务被拒绝执行了
有任务被拒绝执行了
任务17提交
任务14开始执行
任务18提交
任务19提交
任务20提交
任务21提交
有任务被拒绝执行了
有任务被拒绝执行了
任务22提交
任务23提交
任务24提交
任务25提交
任务26提交
有任务被拒绝执行了
有任务被拒绝执行了
有任务被拒绝执行了
有任务被拒绝执行了
有任务被拒绝执行了
任务27提交
有任务被拒绝执行了
任务28提交
有任务被拒绝执行了
任务29提交
》》》线程数量10
>>>任务队列5
》》》线程数量10
>>>任务队列5
任务1执行完成
任务0执行完成
任务2执行完成
任务7开始执行
任务3执行完成
任务5开始执行
任务6开始执行
任务8开始执行
任务13执行完成
任务4执行完成
任务14执行完成
任务9开始执行
任务12执行完成
任务10执行完成
任务11执行完成
》》》线程数量10
>>>任务队列0
》》》线程数量10
>>>任务队列0
》》》线程数量10
>>>任务队列0
任务7执行完成
任务5执行完成
任务8执行完成
任务6执行完成
任务9执行完成
》》》线程数量10
>>>任务队列0
*/

SynchronousQueue

SynchronousQueue不是一个真正的队列，因为它不会为队列中元素维护存储空间。 它维护一组线程，这些线程在等待着把元素加入或移出队列。put() 往queue放进去一个element以后就一直wait直到有其他thread进来把这个element取走。take() 取出并且remove掉queue里的element（认为是在queue里的。。。），取不到东西他会一直等。

public static void test3() throws InterruptedException{
        SynchronousQueue queue = new SynchronousQueue();
        new Thread(new Runnable() {
            @Override
            public void run () {
                try {
                    System.out.println("加入之前");
                    queue.put("新数据1");
                    System.out.println("加入之后");
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
        Thread.currentThread().sleep(100L);
        new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    Thread.sleep(3000);
                    System.out.println("取出数据之前");
                    String takedValue = queue.take();
                    System.out.println("取出来的数据： "+takedValue);
                    System.out.println("取出数据之后");
                }catch(InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
/*
加入之前
取出数据之前
取出来的数据： 新数据1
取出数据之后
加入之后

*/

Executors工具类

newFixedThreadPool(int nThreads)创建一个固定大小，任务队列容量无界的线程池，核心线程数=最大线程数
newCachedThreadPool 创建的是一个大小无界的缓冲线程池，他的任务队列是一个同步队列，任务加入到池中，如果池中有空闲线程，则用空闲线程执行，如果无 则创建新线程执行，池中的线程空袭七年超过60s将被销毁释放，线程数随任务的多少而变化，适用于执行耗时较小的异步任务，池的核心线程数为0，最大线程数=Integet.MAX_VALUE
newSingleThreadExecutor() 只有一个线程来执行无边界任务队列的单一线程池，该线程池确保任务按加入的顺序一个一个的依次执行，当唯一的线程因任务异常终止时，将创建一个新的线程来继续执行后续的任务，与newFixedThreadPool的区别在于，单一线程池的池大小在newSingleThreadExecutor方法中编码，不能在改变的
newScheduledThreadPool(int corePoolSize) 能定时执行任务的的线程池，该池的核心线程数由参数指定，最大线程为Integer.MAX_VALUE

如果确定合适数量的线程

计算型任务：cpu数量的1-2倍
IO型任务：相对比计算型任务，需多一些线程，要根据具体的IO阻塞时长进行考量决定，也可以考虑根据需要在一个最小数量和最大数量间自动增减线程数
如tomcat中默认的最大线程数为200

线程消息通知

suspend和resume，

suspend挂起目标线程，通过resume可以恢复线程执行
已被弃用，主要是容易写出锁死的代码
正常使用：

public class Demo {
    public static String ice = null;
    public static void main(String[] arg) throws Exception {
        Demo demo = new Demo();
        demo.test1();
    }
    public void test1() throws Exception{
        Thread thread = new Thread(()->{
            if(ice==null) {
                System.out.println("没有数据:"+ice);
                Thread.currentThread().suspend(); // 挂起线程
            }
            System.out.println("有数据:"+ice);
        });
        thread.start();
        Thread.sleep(1000);
        ice = "1";
        thread.resume(); // 通知有数据了
        System.out.println("发送通知");
    }
}
/*
没有数据:null
发送通知
有数据:1

*/

异常使用：
suspend和resume会出现一种问题，当线程自己拿了锁，并挂起来了，其他线程再去拿锁的话去通知前一个线程会出现抢不到锁的情况

public class Demo {
    public static String ice = null;
    public static void main(String[] arg) throws Exception {
        Demo demo = new Demo();
        demo.test1();
    }
    public void test1() throws Exception{
        Thread thread = new Thread(new Runnable(){
            @Override
            public void run() {
                if(ice==null) {
                    System.out.println("没有数据:"+ice);
                    synchronized(Demo.class) {
                        Thread.currentThread().suspend();
                    }
                }
                System.out.println("有数据:"+ice);
            }
        });
        thread.start();
        Thread.sleep(1000L);
        ice = "1";
        synchronized(Demo.class) {
                        System.out.println("发送通知");
            thread.resume(); // 通知有数据了
        }
    }
}

/*
没有数据:null

*/

还有一种情况是线程里面在6s中的时候执行suspend，但是在3s的时候其他线程就已经调用resume通知了的话，挂起的线程也是接收不到消息的

wait/notify机制

wait 方法导致当前线程等待，加入该对象的等待集合中，并且放弃当前持有的对象锁，
notify/notifyAll方法唤醒一个或所有正在等待这个对象锁的线程
注意1：虽然会wait自动解锁，但是对顺序有要求，如果notify被调用之后，才开始wait方法的调用，线程会永远处于waiting状态
注意2：这些方法只能由同一对象锁的持有者线程调用，也就是卸载同步快里面，否则会抛出lllegalMStateException异常

wait/notify只能在synchronized关键字中使用

public void test2() {
        try {
            wait();
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
/*
Exception in thread "main" java.lang.IllegalMonitorStateException
    at java.lang.Object.wait(Native Method)
    at java.lang.Object.wait(Unknown Source)
    at com.Hello.ScannerTest.Demo.test2(Demo.java:11)
    at com.Hello.ScannerTest.Demo.main(Demo.java:7)

*/

public void test2() {
        try {
            synchronized(this) {
                wait();
            }
        }catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
// 无异常

正常用法

public void test3() throws Exception {
        new Thread(()->{
            if(ice==null) {
                synchronized(this){
                    try {
                        System.out.println("没用数据："+ice);
                        this.wait();
                        System.out.println("拿到数据:"+ice);
                    }catch(InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                
            }
        }).start();
        Thread.sleep(1000L);
        ice = "1";
        synchronized(this) {
            System.out.println("拿到锁，通知");
            this.notifyAll();
        }
    }
/*
没用数据：null
拿到锁，通知
拿到数据:1

*/

注意：此处使用的是lambda表达式，里面的this会指向父级，所以这里两个synchronized里面的this都是在同一个作用域下的，所以这里的this会通知到，没问题，也就是上面所说的需要注意的第二点，方法只能在同一个线程线程锁的对象里面调用
错误示范：

public void test3() throws Exception {
        new Thread(new Runnable(){
            @Override
            public void run () {
                if(ice==null) {
                    synchronized(this){
                        try {
                            System.out.println("没用数据："+ice);
                            this.wait();
                            System.out.println("拿到数据:"+ice);
                        }catch(InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    
                }
            }
        }).start();
        Thread.sleep(1000L);
        ice = "1";
        synchronized(this) {
            System.out.println("拿到锁，通知");
            this.notifyAll();
        }
    }

/*
没用数据：null
拿到锁，通知

*/

需要改成这样

public class Demo {
    public static String ice = null;
    public static void main(String[] arg) throws Exception {
        Demo demo = new Demo();
        demo.test3();
    }
    public void test3() throws Exception {
        new Thread(new Runnable(){
            @Override
            public void run () {
                if(ice==null) {
                    synchronized(Demo.class){
                        try {
                            System.out.println("没用数据："+ice);
                            Demo.class.wait();
                            System.out.println("拿到数据:"+ice);
                        }catch(InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    
                }
            }
        }).start();
        Thread.sleep(1000L);
        ice = "1";
        synchronized(Demo.class) {
            System.out.println("拿到锁，通知");
            Demo.class.notifyAll();
        }
    }
}
/*
没用数据：null
拿到锁，通知
拿到数据:1
*/

park/ unpark机制

线程调用park则等待“许可”, unpark为线程提供许可
调用unpark之后再调用park线程会直接运行
提前调用的unpark不叠加，连续多次调用unpark之后，第一次调用park后会拿到“许可”,直接运行，后续调用会进入等待

package com.Hello.ScannerTest;

import java.util.concurrent.locks.LockSupport;

public class ParkUnparkDemo {
    public static void main(String args[]) throws Exception {
        ParkUnparkDemo demo = new ParkUnparkDemo();
        demo.test1();
    }
    public static Object ice = null;
    
    public void test1() throws Exception{
        
        Thread consume = new Thread(() -> {
            if(ice == null) {
                System.out.println("准备挂起");
                LockSupport.park();
            }
            System.out.println("完成---");
        });
        consume.start();
        Thread.sleep(3000);
        ice = new Object();
        
        LockSupport.unpark(consume);
        System.out.println("解锁--");
    }
}
/*
准备挂起
解锁--
完成---
*/

注意: 上面的代码用的if语句来判断，时候进入等待状态，这样的做法有问题，官方建议应该在循环中检查等待条件， 因为处于等待状态的线程可能会收到错误警报和唤醒，如果不在循环中检测等待条件，程序会在没有满足条件下推出，
为唤醒： 是指线程并非因为notify, notifyall, unpark等api调用而意外唤醒，是更底层原因导致的
如上面代码

Thread consume = new Thread(() -> {
            if(ice == null) { 
                System.out.println("准备挂起");
                LockSupport.park();
            }
            System.out.println("完成---");
        });
/*
如果ice不满足条件， Locksupport.park()突然被唤醒,那么就会执行下面的 “完成---”， 
*/
while(ice == null) { 
                System.out.println("准备挂起");
                LockSupport.park();
            }
当if改成while后，即使被唤醒了，还是不满足条件，程序继续被挂起，等待着

你可能感兴趣的:(java多线程)

  • Java多线程的可重入和不可重入 @See you later Javajava开发语言
    在Java中，可重入（Reentrant）和不可重入（Non-reentrant）这两个概念通常用于描述多线程环境下的同步方法或代码块的行为。可重入（Reentrant）可重入是指一个线程持有某个锁（Lock）时，可以再次请求同一个锁而不会被锁阻塞。换句话说，如果一个线程获取了某个对象的锁，它可以再次请求这个锁而不会导致死锁。Java中的synchronized关键字就是可重入的。当一个线程获取了
  • Java多线程：深入探索与详细解析 m0_63550220 java开发语言
    1.基础概念与重要性在Java编程中，多线程是并发编程的基石，它允许应用程序同时执行多个任务。这种能力不仅提高了程序的执行效率，还增强了其响应性和用户界面的流畅性。随着现代计算机系统的多核化趋势，多线程编程变得越来越重要，因为它能够充分利用硬件资源，提升程序的总体性能。线程（Thread）：作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线
  • JAVA多线程基础篇 8、线程隔离与ThreadLocal 悟空学编程 JAVA多线程基础篇java开发语言后端
    文章目录1.ThreadLocal的使用示例2.ThreadLocal的使用场景2.1线程隔离的数据库连接与事务2.2线程隔离的session会话3.ThreadLocal原理4.ThreadLocal与内存泄露4.1Java语言将Entry设计为弱引用4.2记得手动remove总结在多线程并发环境中，要保证线程并发安全总体有2类方法。使用锁，在访问资源时是互斥的、原子性的。这个锁可以是Synch
  • java多线程:模拟ThreadLocal ╭╯Erica 并发编程java多线程
    ThreadLocal存储的变量，同一线程下可见，不同线程不可见packagecom.tuyrk.chapter10;importjava.util.HashMap;importjava.util.Map;/***模拟ThreadLocal**/publicclassThreadLocalSimulator{privatefinalMapstorage=newHashMapthreadLocal=
  • Java多线程同步工具类：Semaphore原理剖析 JermeryBesian Javajavajvm面试多线程
    Java多线程同步工具类：Semaphore原理剖析文章目录Java多线程同步工具类：Semaphore原理剖析Semaphore原理实战案例前驱知识准备：AbstractQueuedSynchronizer队列同步器[Java多线程之：队列同步器AbstractQueuedSynchronizer原理剖析]Semaphore原理Semaphore也就是信号量，提供了资源数量的并发访问控制，可以用
  • 普通公司员工的编程水平与阿里巴巴有多大差距？ Java机械师
    BAT的牛人多，普通人也多，虽然他们不是每个人都能达到令人仰望的技术水平，但毕竟平台高，所以眼光会变得宽阔；代码要求更为严格，所以普通的程序员也会被逼变得更优秀；身边的牛人多，普通的程序员也会受到影响，提升的更快。image正好今天看到一篇文章，是讲去阿里的面试经历，也分享给大家，看看自己离着【进】阿里还有多大的差距。Java多线程线程池的原理，为什么要创建线程池？线程的生命周期，什么时候会出现僵
  • java多线程缓存_java – 线程的多线程访问和变量缓存 weixin_39900736 java多线程缓存
    问题是java只是一个规范.有许多JVM实现和物理操作环境的示例.在任何给定的组合上,动作可能是安全的或不安全的.例如,在单处理器系统上,示例中的volatile关键字可能完全没必要.由于存储器和语言规范的编写者无法合理地考虑可能的操作条件集,因此他们选择将某些模式列入白名单,这些模式可以保证适用于所有兼容的实现.遵守这些准则可确保您的代码可以在目标系统上运行,并且可以合理地移植.在这种情况下,“
  • “全栈2019”Java多线程第五十二章：LockSupport等待截止时间 人人都是程序员
    难度初级学习时间10分钟适合人群零基础开发语言Java开发环境JDKv11IntelliJIDEAv2018.3文章原文链接“全栈2019”Java多线程第五十二章：LockSupport等待截止时间下一章“全栈2019”Java多线程第五十三章：ThreadLocal简单介绍学习小组加入同步学习小组，共同交流与进步。方式一：加入编程圈子。方式二：关注头条号Gorhaf，私信“Java学习小组”。
  • JAVA多线程异步与线程池------JAVA 旧约Alatus JAVA#JUC多线程java缓存后端mybatis微服务springbootspring
    初始化线程的四种方式继承Thread实现Runnable接口实现Callable接口+FutureTask(可以拿到返回结果,可以处理异常)线程池继承Thread和实现Runnable接口的方式,主进程无法获取线程的运算结果,不适合业务开发实现Callable接口+FutureTask可以获取线程内的返回结果,但是不利于控制服务器的线程资源,容易导致资源耗尽通过线程池的方式性能稳定,且可以获取结果
  • JAVA多线程等待唤醒机制 我来变强了 JAVAjava
    为什么要处理线程间通信：当我们需要多个线程来共同完成一件任务，并且我们希望他们有规律的执行，那么多线程之间需要一些通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即——等待唤醒机制。这是
  • Java多线程中的锁机制：深入解析synchronized与ReentrantLock 杰哥在此 Java系列java开发语言
    在Java多线程编程中，锁机制是确保线程安全的关键手段。当我们需要控制多个线程对共享资源的访问时，锁可以帮助我们实现这一目标。Java提供了两种主要的锁机制：synchronized关键字和ReentrantLock接口。本文将深入解析这两种锁机制的工作原理、使用场景以及性能特点。一、synchronized关键字synchronized是Java提供的一种内置锁机制，它可以用来修饰方法或代码块。
  • Java笔试面试题之多线程常见考点总结 工程师老罗 Java笔试面试题AI答java开发语言
    Java多线程面试题涵盖了Java多线程编程的多个重要方面，主要考察面试者对Java并发编程的理解和应用能力。以下是常见的考点总结：基本概念与区别：进程与线程的区别：进程是资源分配的基本单位，线程是CPU调度的基本单位，线程共享进程资源。Java堆与栈的区别：堆用于存储对象实例，栈用于存储局部变量和方法调用。线程创建与状态：线程创建方式：继承Thread类、实现Runnable接口、使用Calla
  • Java笔试面试题之多线程偏门考点总结 工程师老罗 Java笔试面试题AI答java开发语言
    以下一些偏门的Java多线程面试题考点：特定API的深入使用：Semaphore的具体应用场景和实现原理。文档中提到了Semaphore是什么，但没有深入探讨其在实际开发中的使用案例和细节。CyclicBarrier和CountDownLatch的具体实现原理和使用场景差异。尽管文档中提到了两者的区别，但可能缺乏具体的代码示例或更深入的分析。线程安全的高级概念：锁降级（LockDowngrade）
  • 写一个Java多线程应用程序，模拟三个人排队买票，张三、李四和王五买电影票，售票员只有三张10元的钱，电影票10元钱一张。 xinkong1010 j2se多线程javathreadstringclass
    packagecom.online.test;/*编写一个Java多线程应用程序，模拟三个人排队买票，张三、李四和王五买电影票，售票员只有三张10元的钱，电影票10元钱一张。张三拿50元一张的人民币排在李四的前面买票，李四排在王五的前面拿一张20元的人民币买票，王五拿一张10元的人民币买票。*/publicclassMaipiao{publicstaticvoidmain(Stringargs[]
  • 2024年Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列 2301_82257383 程序员javapython数据库
    为什么需要等待队列实现思路代码实现1.新建BlockQueue类2.任务的添加和获取方法定义阻塞添加任务方法put编写堵塞拿取任务方法take带超时时间的阻塞添加方法offer带超时时间的阻塞获取方法poll总结✨️本系列源码均已上传仓库1321928757/Concurrent-MulThread-Demo(github.com)")✨️前言在多线程编程中,线程池是一种非常重要的工具。它可以帮助
  • Java多线程 向阳花自开 Java学习java开发语言多线程
    多线程Java多线程是指在一个程序中同时运行多个任务的能力。想象一下，你正在做一顿大餐，同时煮饭、炒菜、切菜。如果你只能一次做一件事，那整个过程会很慢。但如果你可以同时进行多个任务，比如在煮饭的同时切菜，这样就能节省时间。Java多线程就像这样，它允许你的程序同时处理多个任务，从而提高效率和响应速度。通俗解释：单线程：就像一个人做多件事情，但只能按顺序一个接一个地完成，比如先煮饭，然后炒菜，再切菜
  • Java多线程 向阳花自开 Java学习java开发语言多线程
    多线程Java多线程是指在一个程序中同时运行多个任务的能力。想象一下，你正在做一顿大餐，同时煮饭、炒菜、切菜。如果你只能一次做一件事，那整个过程会很慢。但如果你可以同时进行多个任务，比如在煮饭的同时切菜，这样就能节省时间。Java多线程就像这样，它允许你的程序同时处理多个任务，从而提高效率和响应速度。通俗解释：单线程：就像一个人做多件事情，但只能按顺序一个接一个地完成，比如先煮饭，然后炒菜，再切菜
  • Java笔试面试题AI答之线程（2） 工程师老罗 Java笔试面试题AI答java面试开发语言
    文章目录7.如何确保N个线程可以访问N个资源同时又不导致死锁？1.资源排序与顺序访问2.资源分配策略3.避免占用并等待4.引入超时机制5.死锁检测与解决6.使用高级并发工具7.编程实践8.Java方法可以同时即是static又是synchronized的吗?9.什么是Java多线程同步?10.解释Java中wait和sleep方法的区别？11.如何使用threaddump？如何分析Threaddu
  • java多线程编程-上下文切换 李2牛
    上下文切换（ContextSwitch）是多线程共享同一个处理器的产物。线程活性故障死锁（Deadlock）：鹬蚌相争的场景锁死：绝情花毒世界上只有一枚解药可以解除，然后这枚解药没了。中毒的人永远无法解毒。活锁：小猫试图咬自己的尾巴但是它总是追着自己的尾巴咬，始终无法咬到。活锁的外在表现是可能处于RUNNABLE状态，但是线程的任务并没有实际的进展，一直在做无用功。饥饿：某些线程始终无法获取资源，
  • 深度分析：Java多线程，线程安全，并发包 前程有光
    1：synchronized（保证原子性和可见性）1.同步锁。多线程同时访问时，同一时刻只能有一个线程能够访问使synchronized修饰的代码块或方法。它修饰的对象有以下几种：修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象修改一个静
  • Java系列：Java多线程编程经典问题详解，深入解析Java多线程生命周期、死锁、活锁与饥饿、守护线程等问题 码农超哥同学 Java编程java开发语言
    多线程编程是Java语言中的一个高级主题，它在提高程序性能和响应性方面起着至关重要的作用。本文旨在帮助Java学习人员深入理解多线程的概念，并准备相关的技术面试。线程与进程在深入多线程之前，我们需要理解线程与进程的基本概念。进程是程序执行的一个实例，它拥有自己的内存空间和系统资源。而线程是进程内部的一个执行序列，是CPU调度和分派的基本单位。一个进程可以有多个线程，这些线程共享进程的资源，但每个线
  • Java系列：Java多线程常见面试题，Java多线程必须掌握的知识点，理解线程池、线程安全、线程并发、性能优化等常见问题才是合格的Java程序员 码农超哥同学 Java编程java性能优化开发语言
    多线程编程在Java中是一个非常重要且复杂的领域，涉及许多经典问题。也是面试过程中最常被问及的考题，如果不能掌握这些问题，将不能称为一个合格的Java编程人员。那么Java多线程都有哪些常见问题，以及必须要掌握的知识点呢？本篇文章将列举一些基本知识点。以下是一些常见的问题：线程的创建与运行：如何创建线程？有哪些方法？（例如：继承Thread类，实现Runnable接口，使用Callable和Fut
  • java多线程——并发数据不一致java中的解决方案 台风天赋 java多线程多线程java并发编程
    多线程并发编程线程安全主要是由于多线程并发、同时操作共享变量导致的数据不一致。至于共享变量，需要涉及到计算机体系结构的内容：因为现代计算机都一般是设置了两级甚至三级cache。以两级cache为例：假设此时有两个CUP， 线程1 线程2   |   |   v   v  CUP1  CUP2   |   |   v   v  Cache1-1 Cache2-1     |     V    公用c
  • 【Java多线程】线程安全问题与解决方案 Hacynn java开发语言笔记线程安全jvm安全
    目录1、线程安全问题1.2、线程安全原因2、线程加锁2.1、synchronized关键字2.2、完善代码2.3、对同一个线程的加锁操作3、内容补充3.1、内存可见性问题3.2、指令重排序问题3.3、解决方法3.4、总结volatile关键字1、线程安全问题某个代码，无论是单线程下执行还是多线程下执行都不会产生bug，被称之为“线程安全”；如果在单线程下执行正确，但是多线程下会产生bug，被称之为
  • Java多线程系列——同步关键字 飞影铠甲 Javajava数据结构开发语言c++算法
    目录一、线程安全和数据不一致性二、synchronized关键字的作用三、synchronized工作原理四、锁的级别五、synchronized的优点与缺点六、实战应用七、总结在Java中，synchronized关键字是并发编程中的一个基本构建块，用于控制多个线程对共享资源的访问，以确保数据的一致性和线程的安全。在深入研究synchronized关键字的工作原理之前，我们需要理解在多线程环境中
  • JAVA面试题分享五百五十一：线程池使用不当的五个坑 之乎者也· JAVA面试题分享java开发语言
    目录坑一：线程池中异常消失问题原因解决方法优雅的进行线程池异常处理坑二：拒绝策略设置错误导致接口超时问题原因解决方法坑三：重复创建线程池导致内存溢出问题原因解决方法坑四：共用线程池执行不同类型任务导致效率低下问题原因解决方法坑五：使用ThreadLocal和线程池的不兼容问题问题原因解决方法总结线程池是Java多线程编程中的一个重要概念，它可以有效地管理和复用线程资源，提高系统的性能和稳定性。但是
  • Java多线程学习之多线程案例 YCY^v^ JavaHMJavajava
    多线程练习1(卖电影票)1、继承Thread类的方式自定义开发一个MyThread类，来继承Thread类，重写run方法，定义一个ticket共享变量，表示当前卖的是第几张票，一定要使用static关键字来修饰，这样可以确保每一个线程对象都共享这一个变量。具体代码如下：MyThread类packagetest.MaiPiao.test1;/***@authoryangchenyu*@create
  • Java程序员，你掌握了多线程吗？（文末送书） 小尘要自信 javapython开发语言多线程系统架构
    目录01、多线程对于Java的意义02、为什么Java工程师必须掌握多线程03、Java多线程使用方式04、如何学好Java多线程送书规则摘要：互联网的每一个角落，无论是大型电商平台的秒杀活动，社交平台的实时消息推送，还是在线视频平台的流量洪峰，背后都离不开多线程技术的支持。在数字化转型的过程中，高并发、高性能是衡量系统性能的核心指标，越来越多的公司对从业人员的多线程编程能力提出了更高的要求。《一
  • Java多线程系列——什么是线程 飞影铠甲 Javajava开发语言c++算法
    目录0.引言1.线程是什么？2.Java中的线程3.线程的生命周期4.线程同步与并发问题5.示例：使用synchronized实现线程安全的计数器6.结语0.引言在软件开发中，处理多任务同时执行的需求是非常常见的。Java作为一种强大的编程语言，在并发编程领域有着丰富的支持和成熟的解决方案。本文将介绍Java中的线程，探讨线程的概念、使用方法以及常见的并发问题和解决方案。1.线程是什么？在计算机科
  • Java多线程系列——内存模型JMM 飞影铠甲 Javajava开发语言c++算法
    目录核心思想关键概念1.可见性2.原子性3.有序性工作原理并发工具类对并发编程的影响同步策略JMM的实践意义结语Java内存模型（JavaMemoryModel,JMM）是Java并发编程中的核心概念，其定义了Java虚拟机（JVM）在多线程环境中如何以及何时可以看到其他线程写入的变量值，以及如何同步访问共享变量。JMM解决了可见性、原子性、有序性这些在多线程编程中常见的问题。接下来，我们将详细探
  • java数字签名三种方式 知了ing javajdk
    以下3钟数字签名都是基于jdk7的 1，RSA String password="test"; // 1.初始化密钥 KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA"); keyPairGenerator.initialize(51
  • Hibernate学习笔记 caoyong Hibernate
    1>、Hibernate是数据访问层框架，是一个ORM(Object Relation Mapping)框架，作者为:Gavin King 2>、搭建Hibernate的开发环境      a>、添加jar包:      aa>、hibernatte开发包中/lib/required/所
  • 设计模式之装饰器模式Decorator（结构型） 漂泊一剑客 Decorator
    1. 概述        若你从事过面向对象开发，实现给一个类或对象增加行为，使用继承机制，这是所有面向对象语言的一个基本特性。如果已经存在的一个类缺少某些方法，或者须要给方法添加更多的功能（魅力），你也许会仅仅继承这个类来产生一个新类—这建立在额外的代码上。      
  • 读取磁盘文件txt，并输入String 一炮送你回车库 String
    public static void main(String[] args) throws IOException {    String fileContent = readFileContent("d:/aaa.txt");    System.out.println(fileContent);   
  • js三级联动下拉框 3213213333332132 三级联动
    //三级联动 省/直辖市<select id="province"></select> 市/省直辖<select id="city"></select> 县/区 <select id="area"></select>
  • erlang之parse_transform编译选项的应用 616050468 parse_transform游戏服务器属性同步abstract_code
             最近使用erlang重构了游戏服务器的所有代码，之前看过C++/lua写的服务器引擎代码，引擎实现了玩家属性自动同步给前端和增量更新玩家数据到数据库的功能，这也是现在很多游戏服务器的优化方向，在引擎层面去解决数据同步和数据持久化，数据发生变化了业务层不需要关心怎么去同步给前端。由于游戏过程中玩家每个业务中玩家数据更改的量其实是很少
  • JAVA JSON的解析 darkranger java
    // { // “Total”：“条数”， // Code: 1, // // “PaymentItems”:[ // { // “PaymentItemID”:”支款单ID”, // “PaymentCode”:”支款单编号”, // “PaymentTime”:”支款日期”, // ”ContractNo”:”合同号”， //
  • POJ-1273-Drainage Ditches aijuans ACM_POJ
    POJ-1273-Drainage Ditches http://poj.org/problem?id=1273 基本的最大流，按LRJ的白书写的 #include<iostream> #include<cstring> #include<queue> using namespace std; #define INF 0x7fffffff int ma
  • 工作流Activiti5表的命名及含义 atongyeye 工作流Activiti
    activiti5 - http://activiti.org/designer/update在线插件安装 activiti5一共23张表 Activiti的表都以ACT_开头。 第二部分是表示表的用途的两个字母标识。 用途也和服务的API对应。 ACT_RE_*: 'RE'表示repository。 这个前缀的表包含了流程定义和流程静态资源 （图片，规则，等等）。 A
  • android的广播机制和广播的简单使用 百合不是茶 android广播机制广播的注册
          Android广播机制简介 在Android中，有一些操作完成以后，会发送广播，比如说发出一条短信，或打出一个电话，如果某个程序接收了这个广播，就会做相应的处理。这个广播跟我们传统意义中的电台广播有些相似之处。之所以叫做广播，就是因为它只负责“说”而不管你“听不听”，也就是不管你接收方如何处理。另外，广播可以被不只一个应用程序所接收，当然也可能不被任何应
  • Spring事务传播行为详解 bijian1013 javaspring事务传播行为
            在service类前加上@Transactional，声明这个service所有方法需要事务管理。每一个业务方法开始时都会打开一个事务。         Spring默认情况下会对运行期例外(RunTimeException)进行事务回滚。这
  • eidtplus operate 征客丶 eidtplus
    开启列模式: Alt+C 鼠标选择   OR   Alt+鼠标左键拖动 列模式替换或复制内容(多行): 右键-->格式-->填充所选内容-->选择相应操作 OR Ctrl+Shift+V(复制多行数据,必须行数一致) -------------------------------------------------------
  • 【Kafka一】Kafka入门 bit1129 kafka
    这篇文章来自Spark集成Kafka(http://bit1129.iteye.com/blog/2174765)，这里把它单独取出来，作为Kafka的入门吧   下载Kafka http://mirror.bit.edu.cn/apache/kafka/0.8.1.1/kafka_2.10-0.8.1.1.tgz 2.10表示Scala的版本，而0.8.1.1表示Kafka
  • Spring 事务实现机制 BlueSkator spring代理事务
    Spring是以代理的方式实现对事务的管理。我们在Action中所使用的Service对象，其实是代理对象的实例，并不是我们所写的Service对象实例。既然是两个不同的对象，那为什么我们在Action中可以象使用Service对象一样的使用代理对象呢？为了说明问题，假设有个Service类叫AService，它的Spring事务代理类为AProxyService，AService实现了一个接口
  • bootstrap源码学习与示例：bootstrap-dropdown（转帖） BreakingBad bootstrapdropdown
    bootstrap-dropdown组件是个烂东西，我读后的整体感觉。 一个下拉开菜单的设计： <ul class="nav pull-right"> <li id="fat-menu" class="dropdown">
  • 读《研磨设计模式》-代码笔记-中介者模式-Mediator bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ /* * 中介者模式（Mediator）：用一个中介对象来封装一系列的对象交互。 * 中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。 * * 在我看来，Mediator模式是把多个对象（
  • 常用代码记录 chenjunt3 UIExcelJ#
      1、单据设置某行或某字段不能修改 //i是行号,"cash"是字段名称 getBillCardPanelWrapper().getBillCardPanel().getBillModel().setCellEditable(i, "cash", false); //取得单据表体所有项用以上语句做循环就能设置整行了 getBillC
  • 搜索引擎与工作流引擎 comsci 算法工作搜索引擎网络应用
          最近在公司做和搜索有关的工作，(只是简单的应用开源工具集成到自己的产品中)工作流系统的进一步设计暂时放在一边了，偶然看到谷歌的研究员吴军写的数学之美系列中的搜索引擎与图论这篇文章中的介绍，我发现这样一个关系(仅仅是猜想)   -----搜索引擎和流程引擎的基础--都是图论，至少像在我在JWFD中引擎算法中用到的是自定义的广度优先
  • oracle Health Monitor daizj oracleHealth Monitor
    About Health Monitor Beginning with Release 11g, Oracle Database includes a framework called Health Monitor for running diagnostic checks on the database. About Health Monitor Checks Health M
  • JSON字符串转换为对象 dieslrae javajson
        作为前言,首先是要吐槽一下公司的脑残编译部署方式,web和core分开部署本来没什么问题,但是这丫居然不把json的包作为基础包而作为web的包,导致了core端不能使用,而且我们的core是可以当web来用的(不要在意这些细节),所以在core中处理json串就是个问题.没办法,跟编译那帮人也扯不清楚,只有自己写json的解析了.   
  • C语言学习八结构体，综合应用，学生管理系统 dcj3sjt126com C语言
    实现功能的代码： # include <stdio.h> # include <malloc.h> struct Student { int age; float score; char name[100]; }; int main(void) { int len; struct Student * pArr; int i,
  • vagrant学习笔记 dcj3sjt126com vagrant
    想了解多主机是如何定义和使用的, 所以又学习了一遍vagrant   1. vagrant virtualbox 下载安装 https://www.vagrantup.com/downloads.html https://www.virtualbox.org/wiki/Downloads   查看安装在命令行输入vagrant     2.
  • 14.性能优化-优化-软件配置优化 frank1234 软件配置性能优化
    1.Tomcat线程池 修改tomcat的server.xml文件： <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" maxThreads="1200" m
  • 一个不错的shell 脚本教程 入门级 HarborChung linuxshell
    一个不错的shell 脚本教程 入门级 建立一个脚本 　　Linux中有好多中不同的shell，但是通常我们使用bash (bourne again shell) 进行shell编程，因为bash是免费的并且很容易使用。所以在本文中笔者所提供的脚本都是使用bash（但是在大多数情况下，这些脚本同样可以在 bash的大姐，bourne shell中运行）。 　　如同其他语言一样
  • Spring4新特性——核心容器的其他改进 jinnianshilongnian spring动态代理spring4依赖注入
    Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC  Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API  Spring4新
  • Linux设置tomcat开机启动 liuxingguome tomcatlinux开机自启动
    执行命令sudo gedit /etc/init.d/tomcat6 然后把以下英文部分复制过去。（注意第一句#!/bin/sh如果不写，就不是一个shell文件。然后将对应的jdk和tomcat换成你自己的目录就行了。 #!/bin/bash # # /etc/rc.d/init.d/tomcat # init script for tomcat precesses
  • 第13章 Ajax进阶（下） onestopweb Ajax
    index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
  • Troubleshooting Crystal Reports off BW blueoxygen BO
    http://wiki.sdn.sap.com/wiki/display/BOBJ/Troubleshooting+Crystal+Reports+off+BW#TroubleshootingCrystalReportsoffBW-TracingBOE   Quite useful, especially this part: SAP BW connectivity For t
  • Java开发熟手该当心的11个错误 tomcat_oracle javajvm多线程单元测试
    #1、不在属性文件或XML文件中外化配置属性。比如，没有把批处理使用的线程数设置成可在属性文件中配置。你的批处理程序无论在DEV环境中，还是UAT（用户验收 测试）环境中，都可以顺畅无阻地运行，但是一旦部署在PROD 上，把它作为多线程程序处理更大的数据集时，就会抛出IOException，原因可能是JDBC驱动版本不同，也可能是#2中讨论的问题。如果线程数目 可以在属性文件中配置，那么使它成为
  • 正则表达式大全 yang852220741 html编程正则表达式
    今天向大家分享正则表达式大全，它可以大提高你的工作效率 正则表达式也可以被当作是一门语言，当你学习一门新的编程语言的时候，他们是一个小的子语言。初看时觉得它没有任何的意义，但是很多时候，你不得不阅读一些教程，或文章来理解这些简单的描述模式。 一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他