接着上一篇章继续说 这个需要结合着具体的案例来进行分析。 结合着我之前写的一篇文章：事务失效 看下代码： @Transactional public void sellProduct() throws ClassNotFoundException { log.info("----------------->>>>>>>开启日志<<<<<------------------------"); LOC
1.概述 await/async:是个新语法，出现C#5.0,.NetFramework在4.5及以上（CLR4.0）是一个语法糖，不是一个全新的异步多线程使用方式. 语法糖：就是编译器提供的新功能 本身并不会产生新的线程，但是依托于Task而存在，所以程序执行时，也是有多线程的 async可以随便添加，可以不用await，但是awai
package Runnable1;//模拟龟兔赛跑public class Race implements Runnable{ //胜利者 private static String winner; @Override public void run() { for (int i = 0; i <=100; i++) { //模拟兔子休息 if (Thread.currentThrea
public static void main(String[] args) throws Exception { //创建线程池 ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("thread-call-runner-%d").build(); ExecutorService executorService = Executors.
一： 1.继承线程嘞，重写Run方法，在run中制定任务代码。 2.创建线程子类对象，并且调用start方法，以启动线程执行。 举个栗子： class NumberThead extends Thread{ public void run() { for(int i=1;i<=100;i++){ System.out.println(Thread.currentThread().getName()+"\t"
public class CompletableFutureDemo02 { private static ThreadPoolExecutor executor=new ThreadPoolExecutor(5, 50, 10, TimeUnit.SECONDS, new LinkedBlockingQueue<>(), Executors.defaultThr
读读 可以共存 读写 不可以共存 写写 不可以共存 package com.luoKing.ReadWrite; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReadWriteLock; import java.util.concurrent.locks.ReentrantReadWriteLock; public class ReadWriteloc
package com.thread; //改变权重，实际调用看cpu心情 //测试线程优先级 public class TestPriority{ public static void main(String[] args) { //主线程默认优先级 System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPr
package com.mydemo; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicReference; import static java.lang.Thread.currentThread; public class SpinLockDemo { AtomicReference<Thread> atomicReference=new AtomicReferen
C# 5.0语法糖，依托Task存在，本身不会产生线程，达到了通过异步方法实现同步效果的目的（解决异步多线程执行顺序难控制的问题） 1.定义 async可以随便添加，可以不用添加await await只能出在Task前面，但是方法必须声明async，不能单独出现 await/async之后，原本没有返回值，可以返回Task
currentThread的详解 currentThread方法是Thread类的一个静态方法，用来获取当前运行的代码段，正在被哪个线程调用。我们先来看一眼源码。 是一个native方法。直接与系统层面做交互。 下面看一段代码 public static void main(String[] args) { String name = Thread.cu
Lamda表达式简化线程创建方式 实际上本质还是实Runnable接口的一种方法，此方法的好处是可以简化代码，利用函数式接口，将原先需要实现Runnable接口重写run方法的部分，简化为 new Runnable(){}形式（创建线程对象时实现接口方法），再简化为函数式接口Lamda表达式方法 public static void
锁分类 公平和非公平锁 并发包中ReentrantLock的创建可以指定构造函数的boolean类型来决定是公平锁还是非公平锁，默认是非公平锁 公平锁 公平锁，在并发环境下，每个线程在获取锁的时候会去查看此锁维护的等待队列，如果为空，或者当前线程为等待队列的第一个，就占有锁，否则加入到等待
/** * 测试Thread中的常用方法： * 1. start():启动当前线程；调用当前线程的run() * 2. run(): 通常需要重写Thread类中的此方法，将创建的线程要执行的操作声明在此方法中 * 3. currentThread():静态方法，返回执行当前代码的线程 * 4. getName():获取当前线程的名字 * 5. setName
8-1 基本概念：程序、进程、线程 程序(program) 是为完成特定任务、用某种语言编写的一组指令的集合。即指一段静态的代码，静态对象。 进程(process) 是程序的一次执行过程，或是正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。——生命周期 如：运行中的Q
一、共同点 当出现互斥资源时，期望一段代码同时只能一个线程访问，如商品抢购活动，多线程同时操作数据库可能导致数据错误。 二、区别 synchronized 是JVM内置的关键字，Lock是java.util.concurrent.Locks 包下的一个接口。 synchronized 不管是否出现异常，会自动释放锁；Lock需要手动
CountDown计数器减一方法，await方法线程等待阻塞，变为零继续执行 import java.io.IOException; import java.util.concurrent.CountDownLatch; public class Asd { public static void main(String []args) throws InterruptedException { CountDownLatch cut=ne
1 package 多线程练习; 2 3 /* 4 线程礼让不一定每次都成功 看CPU调度 5 */ 6 public class ThreadYieldTest { 7 public static void main(String[] args) { 8 Runnable rb1 = ()->{ 9 System.out.println(Thread.currentThread().getN
/** * 读写锁：一个资源可以被多个读线程访问，也可以被多个写线程访问，但是不能同时存在读和写两个线程 * 读读可以共享，读写不能共存，写写不能共存，Synchronized和Lock都是可重入锁 * synchronized是一个关键字，由系统帮助我们释放锁，Lock是一个类，需要我们手动加锁 * 手动释
书上说，执行一次性的线程，可以使用匿名的 Runnable 实例，但是，不知何时使用一次性的线程呢？ public class CreateDemo2New { public static final int MAX_TURN = 5; static int threadNo = 1; public static void main(String[] args) { Thre
//模拟龟兔赛跑 public class Race implements Runnable { //胜利者 private static String winner; @Override public void run() { for (int i = 1; i < 101; i++) { //模拟兔子休息 if(Thread.currentThread().getName().e
自旋锁 首次接触到自旋锁是在AtomicInteger类，其中的GetAndIncrement()方法，是类似于num++的原子性操作。 源码分析：其中的do while就是一个自旋锁 public final int getAndIncrement() { return unsafe.getAndAddInt(this, valueOffset, 1); } public final int getAndAddInt
MIN.PRIORITY：1 MAX_PRIORITY：10 NORM_PRIORITY：5 getPriority()；setPriority(); package thread.state; public class TestPriority { public static void main(String[] args) { System.out.println(Thread.currentThread().getName()+"-->"+Th
public class MyClass { private static Object resourceA = new Object(); private static Object resourceB = new Object(); public static void main(String args[]) { Thread threadA = new Thread( new Runnable() { public void run(
package 线程;public class Race implements Runnable{ //龟兔赛跑 //胜利者 private static String winner; @Override public void run() { for (int i = 0; i <= 100; i++) { //模拟兔子休息 if (Thread.currentThread().getName(
