多线程

CyclicBarrier-循环栅栏 线程到达栅栏时调用await方法被阻塞，只有线程数据达到栅栏设置的阈值时，栅栏放行，所有线程继续执行，此轮结束，栅栏进入下一轮。 案例：3个线程等待栅栏放行 Task import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.CyclicBarrier; public class Task implements Runnable{ private CyclicBarrier cyclicBarrier; public Task(CyclicBarrier cyclicBarrier) { this.cyclicBarrier = cyclicBarrier; } @Override public void run() { try { Thread.sleep(1000); System.out.println(Thread.currentThread().getName() + "准备就绪"); cyclicBarrier.await(); } catch (InterruptedException e) { System.out.println(Thread.currentThread().getName() + "中断了......");

常见的线程协作方式是：生产者/消费者。 一个线程作为生产者，生产要处理数据，比如拿一个线程来生产Order，用户每下一单，此线程就生产一个Order对象。 设置一个仓库，来存放生产出来的Order对象。 一个线程作为消费者，消费|处理仓库中的Order对象（打印订单、拣货、发货）。 demo 订单处理流程 1、用一个类来封装要处理的数据 public class Order { private int id; //... public Order(int id) { this.id = id; } public int getId() { return id; } //...... } 2、仓库 import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; public class OrderStorage { //使用阻塞队列作为仓库 private BlockingQueue<Order> queues; //默认仓库容量为50 public OrderStorage() { this.queues = new LinkedBlockingQueue<>(50); } //初始化仓库容量 public OrderStorage(int capacity) {

//创建并返回一个线程池 ExecutorService es = Executors.newSingleThreadExecutor(); //此线程池只能容纳一个线程。放入的线程会依次执行，上一个执行完毕，才会执行下一个。 // ExecutorService es = Executors.newFixedThreadPool(10); //指定能容纳的最大线程数，达到最大数后无法扩容。这个用得最多 // ExecutorService es = Executors.newScheduledThreadPool(10); //指定线程池的初始大小，达到初始值后可以继续放入线程，会自动扩容，最大线程数受限于JVM的资源 // ExecutorService es = Executors.newCachedThreadPool(); //最大线程数受限于jvm的资源，如果一个线程空闲多少秒（默认60s），会自动回收该线程 //线程要自己放进去 es.execute(new Thread1()); //往线程池中放入一条线程，并开始执行此线程 es.execute(new Thread2()); //可以是extends Thread的类，也可以是实现Runnable接口的类 //es.submit(new Thread2()); //submit()和execute()作用差不多

1、线程概述 　　 进程：运行在自己的地址空间之内的自包容的程序，是一个动态执行的过程。 比如我打开记事本写一个.txt文件这个过程是一个进程；打开eclipse写一个程序这个过程是一个进程；运行这个程序也是一个进程； 人跑50m短跑这个过程也可以说是一个进程。 　 　线程：是比进程更小的执行单位，是一个个独立的子任务，一个线程就是在进程中的一个的单一的顺序控制流。 比如运行一个.java文件时，主线程就是立刻启动运行；50m短跑的一个同学是一个线程；比赛100m x 4 这个过程是一个进程，这个进程给参赛的4位同学都分配了任务（每位同学跑100m）。 　　从上我们可以看到 进程之间相互隔开，互不影响，彼此不干涉的 ；而 同一个进程之间的线程之间时共享资源的 （接力赛的接力棒）， 线程之间的执行顺序也是不确定的 ，在这个100 x 4 比赛中，每个同学跑第几棒是不确定的，顺序是由leader（这里我们假设是班主任）来确定的，此时班主任担任的就是一个CPU在分配资源的角色。 　　 多线程：顾名思义就是一个进程中有多个线程。 java的线程机制是抢占式，这表示调度机制会周期性地中断线程，讲上下文切换到另一个线程，从而为每个线程都提供时间片，使得每个线程都分配到数量合理的事件驱动它的任务。 　　 注意： 多线程是不能提高运行效率的，相反的在单处理器上还会降低一些运行效率

一、线程的定义 　 　进程（Process） 是Windows系统中的一个基本概念，它 包含着一个运行程序所需要的资源 。进程之间是相对独立的，一个进程无法访问另一个进程的数据（除非利用分布式计算方式），一个进程运行的失败也不会影响其他进程的运行，Windows系统就是利用进程把工作划分为多个独立的区域的。 进程可以理解为一个程序的基本边界 。 　　 线程（Thread） 是 进程中的基本执行单元 ，在 进程入口执行的第一个线程被视为这个进程的主线程 。在.NET应用程序中，都是以Main()方法作为入口的，当调用此方法时系统就会自动创建一个主线程。线程主要是由CPU寄存器、调用栈和线程本地存储器（Thread Local Storage，TLS）组成的。CPU寄存器主要记录当前所执行线程的状态，调用栈主要用于维护线程所调用到的内存与数据，TLS主要用于存放线程的状态信息。 　　 多线程 ，在单CPU系统的一个单位时间（ time slice）内， CPU只能运行单个线程 ， 运行顺序取决于线程的优先级别 。如果在单位时间内线程未能完成执行，系统就会把线程的状态信息保存到线程的本地存储器（TLS）中，以便下次执行时恢复执行。而多线程只是系统带来的一个假象，它在多个单位时间内进行多个线程的切换。因为切换频密而且单位时间非常短暂，所以多线程可以被视作同时运行。 　　

3 月，跳不动了？>>> 总结写在前面： 1.注意设置的信号量的初值。 2.不管如何变，只要牢牢的抓住同步和互斥来分析问题。 3. 先靠滤同步情况即所有“等待”情况。有几个 “ 等待”信号量类型就有几个。 4. 接下来 靠滤 要互斥处理的资源。 先讲讲 PV 操作的起源和用法。 1962 ，荷兰学者 Dijksrta 在参与 X8 计算机的开发中设计并实现了具有多道程序运行能力的操作系统 ——THE Multiprogramming System 。为了解决这个操作系统中进程（线程）的同步与互斥问题，他巧妙地利用火车运行控制系统中的“信号灯”（ semaphore ，或叫“信号量”）概念加以解决。信号量的值大于 0 时，表示当前可用资源的数量；当它的值小于 0 时，其绝对值表示等待使用该资源的进程个数。注意，这个信号量的值仅能由 PV 操作来改变。 PV 操作由 P 操作原语和 V 操作原语组成（原语也叫原子操作 Atomic Operation ，是不可中断的过程），对信号量（注意不要和Windows中的 信号量机制 相混淆）进行操作，具体定义如下： P(S) ： ①将信号量 S 的值减 1 ，即 S=S-1 ； ②如果 S>=0 ，则该进程继续执行；否则该进程置为等待状态。 V(S) ： ①将信号量 S 的值加 1 ，即 S=S+1 ； ②该进程继续执行

10-线程控制之休眠线程 线程休眠： public static void sleep(long millis) 控制当前线程休眠若干 毫秒 （1秒= 1000毫秒 1秒 = 1000 * 1000 * 1000纳秒 1000000000） 1 public class day23_10线程控制之休眠线程 { 2 /* 3 * 线程睡眠 4 * public static void sleep(long millis) 5 */ 6 public static void main(String[] args) { 7 ThreadSleep ts1=new ThreadSleep(); 8 ThreadSleep ts2=new ThreadSleep(); 9 ThreadSleep ts3=new ThreadSleep(); 10 11 ts1.setName("虎兔"); 12 ts2.setName("兔兔"); 13 ts3.setName("虎虎"); 14 15 ts1.start(); 16 ts2.start(); 17 ts3.start(); 18 } 19 } 20 21 class ThreadSleep extends Thread{ 22 @Override 23 public void run() { 24 for(int x=0;x<100;x+

我们在编程的时候，有时会使用多线程来解决问题，比如你的程序需要在后台处 理一大堆数据，但还要使用户界面处于可操作状态；或者你的程序需要访问一些外部资源如数据库或网络文件等。这些情况你都可以创建一个子线程去处理，然而， 多线程不可避免地会带来一个问题，就是线程同步的问题。如果这个问题处理不好，我们就会得到一些非预期的结果。 在网上也看过一些关于线程同步的文章，其实线程同步有好几种方法，下面我就简单的做一下归纳。 一、volatile关键字 volatile是最简单的一种同步方法，当然简单是要付出代价的。它只能在变量一级做同步，volatile的含义就是告诉处理器， 不要将我放入工作内存， 请直接在主存操作我。（【转自 www.bitsCN.com 】）因此，当多线程同时访问该变量时，都将直接操作主存，从本质上做到了变量共享。 能够被标识为volatile的必须是以下几种类型：（摘自MSDN） Any reference type. Any pointer type (in an unsafe context). The types sbyte, byte, short, ushort, int, uint, char, float, bool. An enum type with an enum base type of byte, sbyte, short, ushort, int

线程就栈寄存那些东西，占用内存小 内存数据的共享问题import osimport timefrom threading import Thread# 多线程并发# def func(a,b):# global g# g = 0# print(g,os.getpid())## g = 100# t_lst = []# for i in range(10):# t = Thread(target=func,args=(i,5))# t.start()# t_lst.append(t)# for t in t_lst : t.join()# print(g) # class MyTread(Thread):# def __init__(self,arg): #重写_init_方法# super().__init__()# self.arg = arg# def run(self): #必须定义run# time.sleep(1)# print(self.arg)## t = MyTread(10)# t.start()# 进程 是 最小的 内存分配单位# 线程 是 操作系统调度的最小单位# 线程直接被CPU执行,进程内至少含有一个线程,也可以开启多个线程 # 开启一个线程所需要的时间要远远小于开启一个进程 # 多个线程内部有自己的数据栈,数据不共享 #

内容概要 操作系统介绍 进程 线程 协程 二. 进程 python并发编程之多进程理论部分 在python程序中的进程操作 　　运行中的程序就是一个进程。所有的进程都是通过它的父进程来创建的。因此，运行起来的python程序也是一个进程，那么我们也可以在程序中再创建子进程。多个进程可以实现并发效果，也就是说，当我们的程序中存在多个进程的时候，在某些时候，就会让程序的执行速度变快。创建进程这个功能需要借助python中强大的模块。 multiprocess模块 　 multiprocess不是一个模块而是python中一个操作、管理进程的包。 这个包中几乎包含了和进程有关的所有子模块。大致分为四个部分：创建进程部分，进程同步部分，进程池部分，进程之间数据共享。 multiprocess.process模块 process模块介绍 　　process模块是一个创建进程的模块，借助这个模块，就可以完成进程的创建。 class Process(object): def __init__(self, group=None, target=None, name=None, args=(), kwargs={}): self.name = '' self.daemon = False self.authkey = None self.exitcode = None self.ident = 0