源码位置 : java.util.concurrent.locks.AbstractQueuedSynchronizer
在准备开始详细分析java多线程源码时，发现了这样一个问题，也就是说，在面试的时候经常要求，手写阻塞队列，或者手写一个程序，交替打印1-10000。于是，看到这里经不住动手一试。
在 Java 中，多线程是指同时执行两个或多个线程以最大限度地利用 CPU 的过程。 Java 中的线程是一个轻量级进程，只需要较少的资源即可创建和共享进程资源。
在提交事务时检查自己上次读取这条记录后，是否有其他事务修改了这条记录，如果没有则提交，如果被修改了则回滚。 在对数据库进行处理的时候，乐观锁并不会使用数据库提供的锁机制。
锁，通常被用来实现共享数据的访问，为每一个共享的数据，创建一个Lock对象（一把锁），当需要访问这个共享的资源时，可以调用acquire方法来获取一个锁的对象，当共享资源访问结束后，在调用release方法去解锁。
在前面关于wait/notify及notifyAll方法的时候，notify在源码的注释中说到notify选择唤醒的线程是任意的，但是依赖于具体实现的jvm。原文如下：
在笔者面试过程时，经常会被问到各种各样的锁，如乐观锁、读写锁等等，非常繁多，在此做一个总结。介绍的内容如下：
在并发编程中，经常遇到多个线程访问同一个 共享资源 ，这时候作为开发者必须考虑如何维护数据一致性，在java中synchronized关键字被常用于维护数据一致性。synchronized机制是给共享资源上锁，只有拿到锁的线程才可以访问共享资源，这样就可以强制使得对共享资源的访问都是顺序的。
在Java中创建线程有两种方法：使用Thread类和使用Runnable接口。在使用Runnable接口时需要建立一个Thread实例。因此，无论是通过Thread类还是Runnable接口建立线程，都必须建立Thread类或它的子类的实例。Thread类的构造方法被重载了八次，构造方法如下：
有很多Python语言的协程库，如：tornado、asyncio等。这些库在使用时需要使用特定的语法，如：async/await，对于非协程的代码需要改写才能以协程方式运行。
请解释什么是线程锁，以及如何使用线程锁 线程锁: 目的是将一段代码锁住，一旦获得锁权限，除非释放线程锁，否则其他任何代码都无法获得锁权限 为什么需要线程锁 多线程同时在完成特定的操作时，由于并不是原子操作，所以在完成操作的过程中可能会被打断，去做其他的操作 可能产生脏数据 例如，一个线程读取变量n 【初始值是0】，然后n++, 最后输出n，当访问n++后，被打断，由另外的线程做同样的工作，这时n被加了2次，所以n最后等于2，而不是1 from atexit import register from thre
代码测试 第一种状态切换 - 新建 -> 运行 -> 终止 // 第一种状态切换 - 新建 -> 运行 -> 终止 System.out.println("#######第一种状态切换 - 新建 -> 运行 -> 终止################################"); Thread thread1 = new Thread( new Runnable() { @Override public void run() { System.out.println("thread1当前状态：" + Thread.currentThread().getState().toString()); System.out.println("thread1 执行了"); } }); System.out.println("没调用start方法，thread1当前状态：" + thread1.getState().toString()); thread1.start(); Thread.sleep(2000L); // 等待thread1执行结束，再看状态 System.out.println("等待两秒，再看thread1当前状态：" + thread1.getState().toString()); // thread1.start(); TODO 注意，线程终止之后，再进行调用，会抛出IllegalThreadStateException异常 输出结果: #######第一种状态切换 - 新建 -> 运行 -> 终止################################ 没调用start方法，thread1当前状态：NEW thread1当前状态：RUNNABLE thread1 执行了 等待两秒，再看thread1当前状态：TERMINATED 第二种：新建 -> 运行 -> 等待 -> 运行 -> 终止(sleep方式) System.out.println( "############第二种：新建 -> 运行 -> 等待 -> 运行 -> 终止(sleep方式)###########################"); Thread thread2 = new Thread( new Runnable() { @Override public void run() { try { // 将线程2移动到等待状态，1500后自动唤醒 Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("thread2当前状态：" + Thread.currentThread().getState().toString()); System.out.println("thread2 执行了"); } }); System.out.println("没调用start方法，thread2当前状态：" + thread2.getState().toString()); thread2.start(); System.out.println("调用start方法，thread2当前状态：" + thread2.getState().toString()); Thread.sleep(200L); // 等待200毫秒，再看状态 System.out.println("等待200毫秒，再看thread2当前状态：" + thread2.getState().toString()); Thread.sleep(3000L); // 再等待3秒，让thread2执行完毕，再看状态 System.out.println("等待3秒，再看thread2当前状态：" + thread2.getState().toString()); 输出结果: ############第二种：新建 -> 运行 -> 等待 -> 运行 -> 终止(sleep方式)########################### 没调用start方法，thread2当前状态：NEW 调用start方法，thread2当前状态：RUNNABLE 等待200毫秒，再看thread2当前状态：TIMED_WAITING thread2当前状态：RUNNABLE thread2 执行了 等待3秒，再看thread2当前状态：TERMINATED 第三种：新建 -> 运行 -> 阻塞 -> 运行 -> 终止 System.out.println("############第三种：新建 -> 运行 -> 阻塞 -> 运行 -> 终止#####################
ReentrantLock锁的底层实现已经阐述过了，那么如何使用，本文进行下样例展示，主要说3个：1. lock及中断，2. 申请等待时间，3、公平锁
默认情况下Mono以及Flux都在主线程上运行，有时候可能会阻塞主线程，可以通过设定schedulers让其在其他线程运行。
线程状态 6个状态定义：java.lang.Thread.State New: 尚未启动的线程的线程状态。 Runnable: 可运行线程的线程状态，等待CPU调度。 Blocked: 线程阻塞等待监视器锁定的线程状态。处于synchronized同步代码块或方法中被阻塞。 Waiting: 等待线程的线程状态。下列不带超时的方式：Object.wait、Thread.join、LockSupport.park Timed Waiting: 具有指定等待时间的等待线程的线程状态。下列超时的方式：Thread
理解：就是要给令牌池，可获取信号量（令牌或者许可）、放入信号量。常用于控制并发的线程数，也可用于池类资源的访问控制。
POSIX 全称是 Portable Operating System Interface of UNIX ，表示可移植操作系统接口，本质上是一种编程标准。它定义了操作系统应该为应用程序提供的接口标准，是 IEEE 为要在各种 UNIX 操作系统上运行的软件而定义的一系列 API 标准的总称。
链接：https://juejin.cn/post/6943037393893064734#heading-13
一、概述 多线程的优先级，小伙伴们应该都或多或少的用过或者见到过，但是，对于具体用法可能还是有点不太清楚，这篇文章就对这个问题进行一个探讨，也欢迎小伙伴们一起留言讨论。 在不同的JVM中（JVM也算是一个操作系统），有着不同的CPU调度算法，对于大部分的JVM来说，优先级也是调度算法中的一个参数。 所以，线程优先级在一定程度上，对线程的调度执行顺序有所影响，但不能用于保证线程的执行顺序，因为优先级仅仅是其中一个参数而已，其他参数还可能有线程的等待时间、执行时间等。而且操作系统也可抗能可以完全不用理会JA
之所以想写这个专题，是因为最近在做一个抢占任务的实现。假设数据库很多个任务，在抢占发生之前任务的状态都是FREE。现在假设同时有一堆抢占线程开始工作，抢占线程会查找数据库中状态为FREE的任务，并且将其状态置为BUSY，然后开始执行对应任务。执行完成之后，再将任务状态置为FINISH。任何任务都是不能被重复执行的，即必须保证所有任务都只能被一个线程执行。
在上一篇文章中（Java并发编程：线程的基本状态）我们介绍了线程状态的 5 种基本状态以及线程的声明周期。这篇文章将深入讲解Java如何对线程进行状态控制，比如：如何将一个线程从一个状态转到另一个状态
参考转载：http://rainyear.iteye.com/blog/1734311 http://turandot.iteye.com/blog/1704027 http://www.cnblog
上节提到了线程安全的问题，说了一个例子，1000个人抢100张票，这节就从此案例着手，下面先看一下代码实现：
文章目录 线程和进程的区别 JDK选择长期版本 线程和进程的区别 基础 由来 区别 关系 代码查看主线程 Thread中的start方法和run方法的区别 效果图 代码 分析源码 没有可比性run和star Thread和Runnable是什么关系 本质 源码 代码演示 普通Thread.start()线程-效果图 MyThread 通过Thread类启动Runnable多线程-效果图 MyRunnalbe MyRunnableMain 如何实现处理线程的返回值 如何给run()方法传参 实现的方式主要有三
PS：通过API，演示前面说的几种状态，通过图和代码让大家对这6种状态了解透彻，线程状态的知识点就讲解到这里。下次咱们继续说说线程，一起说说线程终止。
CyclicBarrier字面意思就是回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。
如果你在网上搜索“Python 多线程”，那么你会看到很多文章里面用到了一个关键词，叫做.join()。但是很多人的代码里面都在乱用 join()，例如：
一个标准的线程由线程ID，当前指令指针(PC），寄存器集合和堆栈组成。线程是进程中的一个实体，是被系统独立调度和分派的基本单位，线程本身不拥有系统资源，与进程内的其它线程共享进程的所有资源。一个进程中至少有一个线程，并作为程序的入口，即主线程，其它线程称为工作线程。 多线程，是指从软件或者硬件上实现多个线程并发执行的技术。支持多线程能力的计算机因有硬件支持而能够在同一时间执行多个线程，进而提升整体处理性能。
std::thread 在 <thread> 头文件中声明，因此使用 std::thread 需包含 <thread> 头文件。
Java 中线程的优先级范围为 1~10，是一个 int 类型的值 其中最小的优先级 (MIN_PRIORITY) 为 1 正常优先级 (NORM_PRIORITY) 为 5 最高优先级 (MAX_PRIORITY) 为 10 【源码中定义的线程优先级】
# -*- coding: utf-8 -*- import threading import time class myThread(threading.Thread): def __init__(self, threadname): threading.Thread.__init__(self, name=threadname) def run(self): time.sleep(5) print '%s is running·······done'%self.getName() t=myThread('son thread') #t.setDaemon(True) t.start() if t.isDaemon(): print "the father thread and the son thread are done" else: print "the father thread is waiting the son thread····"
我们首先先创建线程，然后调用start方法来启动线程。最后，我们通过join方法来等待线程的结束，再退出主线程。使用threading.Thread对象可以自动帮我们管理线程锁。
版权声明：署名，允许他人基于本文进行创作，且必须基于与原先许可协议相同的许可协议分发本文 （Creative Commons）
我们平时安装的程序都放在硬盘上,当我们在windows上双击可执行程序(exe)时才会将其运行起来。本质上就是将这个程序加载到内存中,然后CPU才会对该程序的数据和代码进行读取并逐行的执行，一旦将程加载到内存后,此时程序从静态的趟在硬盘上到动态的运行在内存中,我们就将在内存中的程序,称之为进程。
把代码块声明为 synchronized，有两个重要后果，通常是指该代码具有 原子性（atomicity）和 可见性（visibility）。
默认配置（default.jfc of Java 11，default.jfc of Java 12，default.jfc of Java 13，default.jfc of Java 14，default.jfc of Java 15，default.jfc of Java 16，default.jfc of Java 17）:
又叫 守护线程, 用 setDaemon(true) 设置; gc thread(垃圾回收线程) 就是一种守护线程; 守护线程在 JVM里面进行工作
我们工作中，并发编程必然离不开jdk提供的j.u.c中的线程池 ，假设让我们自己去设计一个线程池，该从哪几个方面来着手考虑呢？
高并发编程-自定义简易的线程池（1），体会原理 中只实现了任务队列，我们这里把其余的几个也补充进来
多线程是指程序中包含多个执行流，即在一个程序中可以同时运行多个不同的线程来执行不同的任务，也就是说允许单个程序创建多个并行执行的线程来完成各自的任务。
最近写了涉及线程池及线程的 python 脚本，运行过程中发现一个有趣的现象，线程池中的工作线程出现问题，引发了异常，但是主线程没有捕获异常，还在发现 BUG 之前一度以为线程池代码正常返回。
当一个线程运行时，另一个线程可以调用对应的Thread对象的interrupt()方法来中断它。
调用Thread的start()方法启动线程时，线程的执行顺序是不确定的。也就是说，在同一个方法中，连续创建多个线程后，调用线程的start()方法的顺序并不能决定线程的执行顺序。
Runnable是一个接口，定义一个类MyRunnable实现Runnable接口，实现run()方法，
说到线程就不得不提与之相关的另一概念：进程，那么什么是进程？与线程有什么关系呢？简单来说一个运行着的应用程序就是一个进程，比如：我启动了自己手机上的酷猫音乐播放器，这就是一个进程，然后我随意点了一首歌曲进行播放，此时酷猫启动了一条线程进行音乐播放，听了一部分，我感觉歌曲还不错，于是我按下了下载按钮，此时酷猫又启动了一条线程进行音乐下载，现在酷猫同时进行着音乐播放和音乐下载，此时就出现了多线程，音乐播放线程与音乐下载线程并行运行，说到并行，你一定想到了并发吧，那并行与并发有什么区别呢？并行强调的是同一时刻，并发强调的是一段时间内。线程是进程的一个执行单元，一个进程中至少有一条线程，进程是资源分配的最小单位，线程是 CPU 调度的最小单位。
主要是再进一步加深Python中关于多线程相关函数join()的理解以解多线程的执行过程。这里通过下面的例子来作进一步的说明。
LockSupport是一个线程阻塞工具，可以在线程任意位置让线程阻塞。线程操作阻塞的方式其实还有Thread.suspend()和Object.wait()。而LockSupport与suspend()相比，弥补了由于resume()方法而导致线程被挂起（类似死锁）的问题，也弥补了wait()需要先获得某个对象锁的问题，也不会抛出InterruptedException异常。
内存分为主内存和工作内存，每个线程都有自己的工作内存，如何和主内存的数据同步，产生的数据不一致性，就是我们常说的线程安全，这就需要我们去了解Java内存模型了。
1.背景： countDownLatch是在java1.5被引入，跟它一起被引入的工具类还有CyclicBarrier、Semaphore、concurrentHashMap和BlockingQueue。 存在于java.util.cucurrent包下 2.概念 countDownLatch这个类使一个线程等待其他线程各自执行完毕后再执行。 是通过一个计数器来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在闭锁上等待的线程就可
print '%s : %s' % (threadName, time.ctime(time.time()))
领取专属 10元无门槛券
手把手带您无忧上云
云服务器
ICP备案
实时音视频
即时通信 IM
对象存储
