• 关于

    执行中断可以做什么

    的搜索结果

回答

说实话这乱七八糟一堆文字我看了两边,然后发现真救不了你. ######回复 @刘子玄:操作系统不管理寄存器,现在都是抢占式多线程操作系统,都是在线程释放资源的时候切换到其他进程的(你调用某些api的时候会发生等待和切换操作,然后保存线程执行环境数据)看一下操作系统原理的书籍就知道了.直接切换那个只有纯正的分时操作系统才会去做.现在估计只剩下大型UNIX了######==######靠时钟中断,硬件一定会定时发起时钟中断,中断服务一定会执行,这样就可以进行调度或做其他事了,中断机制由硬件保证。找书看吧,这些问题不是几句说得清。######谢了######在中断产生时,寄存器压栈,在中断结束后,堆栈的数据弹回到寄存器。###### 寄存器操作是汇编级别的最小操作单元,即使是操作系统也不能够管理寄存器. 是计算机有一些指令,能够自己把所有寄存器保存到一个地方.######计算机基础如此博大精深,几十年高科技结晶,不是三天三夜就能说清的,更何况几句话###### 简单2个字压栈.OS的原理很简单,你可以找一些嵌入式的OS开源代码进行阅读,相信读完2个系统的代码后,就对OS核心部分很清楚了. 挑你的一个问题进行回答:" 操作系统是如何让一个程序在规定时间内执行再准确的暂停了?这是如何控制的?"      感觉你还不清楚调度算法的实现.简单的说:硬件中断将其打断,如果需要1ms的进程调度精度,那么就设置时钟中断为1ms. 你可以看下中断部分的代码.       CPU的PC指针即使软件不去设置它也不是固定不变只能向下跑的.当中断发生的时候,PC指针会自动修改到相应中断向量的物理地址上,并且中断时的重要寄存器的值被硬件自动保存. 于是我们就设置一个时钟中断向量(将这个地址上写入我们的代码函数的地址),每18msPC指针会被自动改到这个地方,在这个地方我们根据调度算法,看是继续执行被打断的线程还是切换到更合适的线程上.  感性上,线程/cpu的运行实际上是非常的不连贯, 中途不断的被各种中断疯狂的打断.尤其高响应的硬实时OS,打断应该更加频繁. 我们想干任何事情都可以在中断处理中去做.        此外除了硬件中断,因为硬件功能都是api提供,so程序代码实际上经常会很频繁调用一些系统API,既然调用了系统api,os也完全可以在系统api执行软中断,执行调度算法,把pc指针移到别处去,不再正常的函数返回了(保存好数据,下次调度它时,模拟这个函数返回,应用程序完全不知道发生了什么). ######一个嵌入式OS的代码不过几千行而已. 看完几个 你就精通OS的实现了.不过"知识改变命运", 懂得越多混得越惨, 个人建议你干点其他能赚钱的事情.底层实现的东西,除了吹牛,提升点技术素质,对赚钱来说毫无用处,面试时都没用!!(实际上现在面试都是看算法)  小正太, 根据赚钱来指导自己学习/背诵什么东西.(很心痛的经验)######回复 @MinGKai:haha.反正比赚1个亿简单多了.######“精通”OS有那么简单么…………######这个你放心,我只会把编程当成毕生的爱好,而不会用作工作。

优选2 2020-06-09 16:14:52 0 浏览量 回答数 0

回答

说实话这乱七八糟一堆文字我看了两边,然后发现真救不了你. ######回复 @刘子玄 : 操作系统不管理寄存器,现在都是抢占式多线程操作系统,都是在线程释放资源的时候切换到其他进程的(你调用某些api的时候会发生等待和切换操作,然后保存线程执行环境数据)看一下操作系统原理的书籍就知道了.直接切换那个只有纯正的分时操作系统才会去做.现在估计只剩下大型UNIX了######= =######靠时钟中断,硬件一定会定时发起时钟中断,中断服务一定会执行,这样就可以进行调度或做其他事了,中断机制由硬件保证。找书看吧,这些问题不是几句说得清。######谢了######在中断产生时,寄存器压栈,在中断结束后,堆栈的数据弹回到寄存器。###### 寄存器操作是汇编级别的最小操作单元,即使是操作系统也不能够管理寄存器. 是计算机有一些指令,能够自己把所有寄存器保存到一个地方. ######计算机基础如此博大精深,几十年高科技结晶,不是三天三夜就能说清的,更何况几句话###### 简单2个字 压栈. OS的原理很简单, 你可以找一些嵌入式的OS开源代码进行阅读, 相信读完2个系统的代码后, 就对OS核心部分很清楚了. 挑你的一个问题进行回答: "操作系统是如何让一个程序在规定时间内执行再准确的暂停了?这是如何控制的?"       感觉你还不清楚调度算法的实现.简单的说: 硬件中断将其打断,如果需要1ms的进程调度精度,那么就设置时钟中断为1ms.  你可以看下中断部分的代码.        CPU的PC指针即使软件不去设置它也不是固定不变只能向下跑的. 当中断发生的时候,PC指针会自动修改到相应中断向量的物理地址上,并且中断时的重要寄存器的值被硬件自动保存.  于是我们就设置一个时钟中断向量(将这个地址上写入我们的代码函数的地址), 每18ms PC指针会被自动改到这个地方,在这个地方 我们根据调度算法, 看是继续执行被打断的线程 还是切换到更合适的线程上.   感性上, 线程/cpu 的运行 实际上是非常的不连贯,  中途不断的被各种中断疯狂的打断. 尤其高响应的硬实时OS,打断应该更加频繁.  我们想干任何事情都可以在中断处理中去做.         此外除了硬件中断, 因为硬件功能都是api提供,so程序代码实际上经常会很频繁调用一些系统API, 既然调用了系统api, os也完全可以在系统api执行软中断, 执行调度算法, 把pc指针移到别处去, 不再正常的函数返回了(保存好数据, 下次调度它时,模拟这个函数返回, 应用程序完全不知道发生了什么). ######一个嵌入式OS的代码不过几千行而已.  看完几个  你就精通OS的实现了. 不过"知识改变命运",  懂得越多混得越惨,  个人建议你干点其他能赚钱的事情. 底层实现的东西, 除了吹牛, 提升点技术素质, 对赚钱来说毫无用处, 面试时都没用!! (实际上现在面试都是看算法)   小正太,  根据赚钱来指导自己学习/背诵 什么东西. (很心痛的经验)######回复 @MinGKai : haha. 反正比赚1个亿简单多了.######“精通”OS有那么简单么…………######这个你放心,我只会把编程当成毕生的爱好,而不会用作工作。

爱吃鱼的程序员 2020-05-30 22:45:50 0 浏览量 回答数 0

问题

setTimeout “不执行”和异步

a123456678 2019-12-01 20:25:00 1161 浏览量 回答数 2

阿里云试用中心,为您提供0门槛上云实践机会!

0元试用32+款产品,最高免费12个月!拨打95187-1,咨询专业上云建议!

回答

使用断言的最佳时机偶尔会被提起,通常是因为有人误用,因此我觉得有必要写一篇文章来阐述一下什么时候应该用断言,为什么应该用,什么时候不该用。 对那些没有意识到用断言的最佳时机的人来说,Python的断言就是检测一个条件,如果条件为真,它什么都不做;反之它触发一个带可选错误信息的AssertionError。如下例所示: 很多人将断言作为当传递了错误的参数值时的一种快速而简便的触发异常的方式。但实际上这是错误的,而且是非常危险的错误,原因有两点。首先,AssertionError通常是在测试函数参数时给出的错误。你不会像下面这样编码: 你应该用TypeError来替代,“断言”解决了错误的异常类型。 但是对断言来说更危险也更纠结的是:如果你执行Python时使用了-O或-OO优化标识,这能够通过编译却从来不会被执行,实际上就是说并不能保证断言会被执行。当恰当地使用了断言,这非常好的,但当不恰当地使用了断言,在使用-O标识执行时它将导致代码被彻底中断。 那么我们什么时候应该使用断言呢?如果没有特别的目的,断言应该用于如下情况: 防御性的编程运行时对程序逻辑的检测合约性检查(比如前置条件,后置条件)程序中的常量检查文档(断言也可以用于代码测试,用作一个做事毛手毛脚的开发人员的单元测试,只要能你接受当使用-O标志时这个测试什么都不做。我有时也会在代码中用"assert Fasle"来对还没有实现的分支作标记,当然我希望他们失败。如果稍微更细节一些,或许触发NotImplementedError是更好的选择) 因为程序员是对于代码正确性表现出的信心不同,因此对于什么时候使用断言的意见各不相同。如果你确信代码是正确的,那么断言没有任何意义,因为它们从不会失败,因此你可以放心地移除它们。如果你确信它们会失败(例如对用户输入的数据的检测),你不敢用断言,这样编译就能通过,但你跳过了你的检查。 在以上两种情况之间的情况就显得特别有趣了,那就是当你相信代码是正确的,但又不是特别确定的时候。或许你忘记了一些奇怪的边角情况(因为我们都是人),在这种情况下,额外的运行时检查将帮助你尽可能早地捕获错误,而不是写了一大堆代码之后。 (这就是为什么使用断言的时机会不同。因为我们对代码正确性的信息不同,对于一个人有用的断言,对于另一个人来说却是无用的运行时测试。) 另一个断言用得好的地方就是检查程序中的不变量。一个不变量是一些你能相信为真的条件,除非一个缺陷导致它变成假。如果有一个缺陷,越早发现越好,因此我们需要对其进行测试,但我们不想因为这些测试而影响代码执行速度。因此采用断言,它能在开发时生效而在产品中失效。 一个关于不变量的例子可能是这样的情况。如果你的函数在开始的时候期望一个打开的数据库连接,并且在函数返回后该数据库连接依然是打开的,这是一个函数的不变量: 断言也是一个很好的检查点注释。为了替代如下注释: 当我们执行到这里,我们知道n>2 你可以确保在运行时用以下断言: 断言也是一种防御性的编程形式。你不是在防范当前代码发生错误,而防范由于以后的代码变更发生错误。理想情况下,单元测试应该直到这个作用,但是让我们面对这样一个现实:即使存在单元测试,他们在通常情况下也不是很完备。内建的机器人可能没有工作,但数周以来也没有人注意到它,或者人们在提交代码之前忘记了执行测试。内部检查将是防止错误渗入的另一道防线,尤其对于那些悄悄地失败,但会引起代码功能错误并返回错误结果的情况有效。 假设你有一系列的if...elif代码块,你预先知道变量期望的值: 假设这段代码现在完全正确。但它会一直正确吗?需求变更,代码变更。如果需求变为允许target = w,并关联到run_w_code,那将会发生什么情况?如果我们变更了设置target的代码,但是忘记了改变这个代码块,它就会错误地调用run_z_code(),错误就会发生。对于这段代码最好的方法就是编写一些防御性的检查,这样它的执行,即使在变更以后,要么正确,要么马上失败。 在代码开始添加注释是个好的开端,但是人们都不太喜欢读和更新这些注释,这些注释会很快变得过时。但对于断言,我们可以同时对这块代码编写文档,如果这些断言被违反了,会直接引起一个简单而又直接的失败。 这里的断言同时用于防御性编程和检查文档。我认为这是最优的解决方案: 这诱使开发者去不理代码,移除像value ==c这类不必要的测试,以及RuntimeError的“死代码”。另外,当"unexpected error"错误发生时这个消息将非常窘迫,确实会发生。 合约式设计是断言另一个用得好的地方。在合约式设计中,我们认为函数与其他调用者遵循合约,例如像这样的情况: “如果你传给我一个非空字符串,我保证返回转换成大写的首字母。” 如果合约被破坏了,不管是被函数本身还是调用者,这都会产生缺陷。我们说这个函数需要有前置条件(对期望的参数的限制)和后置条件(对返回结果的约束)。因此这个函数可能是这样的: 合约式设计的目的是,在一个正确的程序里,所有的前置条件和后置条件都将得到处理。这是断言的经典应用,自(这个想法持续)我们发布无缺陷的程序并且将其放入产品,程序将是正确的并且我们可以放心地移除检查。

xuning715 2019-12-02 01:10:08 0 浏览量 回答数 0

问题

为什么SSH 登录时出现如下错误:Too many authentication failures for root

boxti 2019-12-01 22:00:05 1505 浏览量 回答数 0

问题

mysql并发的问题,能不能有办法避免sql出错的情况,数据的完整性怎才能做到……?

a123456678 2019-12-01 20:16:25 1534 浏览量 回答数 2

回答

如果对什么是线程、什么是进程仍存有疑惑,请先Google之,因为这两个概念不在本文的范围之内。 用多线程只有一个目的,那就是更好的利用cpu的资源,因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对,因为反应“多角色”的程序代码,最起码每个角色要给他一个线程吧,否则连实际场景都无法模拟,当然也没法说能用单线程来实现:比如最常见的“生产者,消费者模型”。 很多人都对其中的一些概念不够明确,如同步、并发等等,让我们先建立一个数据字典,以免产生误会。 多线程:指的是这个程序(一个进程)运行时产生了不止一个线程 并行与并发: 并行:多个cpu实例或者多台机器同时执行一段处理逻辑,是真正的同时。 并发:通过cpu调度算法,让用户看上去同时执行,实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源,那么针对这个公用的资源往往产生瓶颈,我们会用TPS或者QPS来反应这个系统的处理能力。 并发与并行 线程安全:经常用来描绘一段代码。指在并发的情况之下,该代码经过多线程使用,线程的调度顺序不影响任何结果。这个时候使用多线程,我们只需要关注系统的内存,cpu是不是够用即可。反过来,线程不安全就意味着线程的调度顺序会影响最终结果,如不加事务的转账代码: void transferMoney(User from, User to, float amount){ to.setMoney(to.getBalance() + amount); from.setMoney(from.getBalance() - amount); } 同步:Java中的同步指的是通过人为的控制和调度,保证共享资源的多线程访问成为线程安全,来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时,提高性能,才是优秀的程序。线程安全的优先级高于性能。 好了,让我们开始吧。我准备分成几部分来总结涉及到多线程的内容: 扎好马步:线程的状态 内功心法:每个对象都有的方法(机制) 太祖长拳:基本线程类 九阴真经:高级多线程控制类 扎好马步:线程的状态 先来两张图: 线程状态 线程状态转换 各种状态一目了然,值得一提的是"blocked"这个状态:线程在Running的过程中可能会遇到阻塞(Blocked)情况 调用join()和sleep()方法,sleep()时间结束或被打断,join()中断,IO完成都会回到Runnable状态,等待JVM的调度。 调用wait(),使该线程处于等待池(wait blocked pool),直到notify()/notifyAll(),线程被唤醒被放到锁定池(lock blocked pool ),释放同步锁使线程回到可运行状态(Runnable) 对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。 此外,在runnable状态的线程是处于被调度的线程,此时的调度顺序是不一定的。Thread类中的yield方法可以让一个running状态的线程转入runnable。内功心法:每个对象都有的方法(机制) synchronized, wait, notify 是任何对象都具有的同步工具。让我们先来了解他们 monitor 他们是应用于同步问题的人工线程调度工具。讲其本质,首先就要明确monitor的概念,Java中的每个对象都有一个监视器,来监测并发代码的重入。在非多线程编码时该监视器不发挥作用,反之如果在synchronized 范围内,监视器发挥作用。 wait/notify必须存在于synchronized块中。并且,这三个关键字针对的是同一个监视器(某对象的监视器)。这意味着wait之后,其他线程可以进入同步块执行。 当某代码并不持有监视器的使用权时(如图中5的状态,即脱离同步块)去wait或notify,会抛出java.lang.IllegalMonitorStateException。也包括在synchronized块中去调用另一个对象的wait/notify,因为不同对象的监视器不同,同样会抛出此异常。 再讲用法: synchronized单独使用: 代码块:如下,在多线程环境下,synchronized块中的方法获取了lock实例的monitor,如果实例相同,那么只有一个线程能执行该块内容 复制代码 public class Thread1 implements Runnable { Object lock; public void run() { synchronized(lock){ ..do something } } } 复制代码 直接用于方法: 相当于上面代码中用lock来锁定的效果,实际获取的是Thread1类的monitor。更进一步,如果修饰的是static方法,则锁定该类所有实例。 public class Thread1 implements Runnable { public synchronized void run() { ..do something } } synchronized, wait, notify结合:典型场景生产者消费者问题 复制代码 /** * 生产者生产出来的产品交给店员 */ public synchronized void produce() { if(this.product >= MAX_PRODUCT) { try { wait(); System.out.println("产品已满,请稍候再生产"); } catch(InterruptedException e) { e.printStackTrace(); } return; } this.product++; System.out.println("生产者生产第" + this.product + "个产品."); notifyAll(); //通知等待区的消费者可以取出产品了 } /** * 消费者从店员取产品 */ public synchronized void consume() { if(this.product <= MIN_PRODUCT) { try { wait(); System.out.println("缺货,稍候再取"); } catch (InterruptedException e) { e.printStackTrace(); } return; } System.out.println("消费者取走了第" + this.product + "个产品."); this.product--; notifyAll(); //通知等待去的生产者可以生产产品了 } 复制代码 volatile 多线程的内存模型:main memory(主存)、working memory(线程栈),在处理数据时,线程会把值从主存load到本地栈,完成操作后再save回去(volatile关键词的作用:每次针对该变量的操作都激发一次load and save)。 volatile 针对多线程使用的变量如果不是volatile或者final修饰的,很有可能产生不可预知的结果(另一个线程修改了这个值,但是之后在某线程看到的是修改之前的值)。其实道理上讲同一实例的同一属性本身只有一个副本。但是多线程是会缓存值的,本质上,volatile就是不去缓存,直接取值。在线程安全的情况下加volatile会牺牲性能。太祖长拳:基本线程类 基本线程类指的是Thread类,Runnable接口,Callable接口Thread 类实现了Runnable接口,启动一个线程的方法:  MyThread my = new MyThread();  my.start(); Thread类相关方法:复制代码 //当前线程可转让cpu控制权,让别的就绪状态线程运行(切换)public static Thread.yield() //暂停一段时间public static Thread.sleep() //在一个线程中调用other.join(),将等待other执行完后才继续本线程。    public join()//后两个函数皆可以被打断public interrupte() 复制代码 关于中断:它并不像stop方法那样会中断一个正在运行的线程。线程会不时地检测中断标识位,以判断线程是否应该被中断(中断标识值是否为true)。终端只会影响到wait状态、sleep状态和join状态。被打断的线程会抛出InterruptedException。Thread.interrupted()检查当前线程是否发生中断,返回booleansynchronized在获锁的过程中是不能被中断的。 中断是一个状态!interrupt()方法只是将这个状态置为true而已。所以说正常运行的程序不去检测状态,就不会终止,而wait等阻塞方法会去检查并抛出异常。如果在正常运行的程序中添加while(!Thread.interrupted()) ,则同样可以在中断后离开代码体 Thread类最佳实践:写的时候最好要设置线程名称 Thread.name,并设置线程组 ThreadGroup,目的是方便管理。在出现问题的时候,打印线程栈 (jstack -pid) 一眼就可以看出是哪个线程出的问题,这个线程是干什么的。 如何获取线程中的异常 不能用try,catch来获取线程中的异常Runnable 与Thread类似Callable future模式:并发模式的一种,可以有两种形式,即无阻塞和阻塞,分别是isDone和get。其中Future对象用来存放该线程的返回值以及状态 ExecutorService e = Executors.newFixedThreadPool(3); //submit方法有多重参数版本,及支持callable也能够支持runnable接口类型.Future future = e.submit(new myCallable());future.isDone() //return true,false 无阻塞future.get() // return 返回值,阻塞直到该线程运行结束 九阴真经:高级多线程控制类 以上都属于内功心法,接下来是实际项目中常用到的工具了,Java1.5提供了一个非常高效实用的多线程包:java.util.concurrent, 提供了大量高级工具,可以帮助开发者编写高效、易维护、结构清晰的Java多线程程序。1.ThreadLocal类 用处:保存线程的独立变量。对一个线程类(继承自Thread)当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本。常用于用户登录控制,如记录session信息。 实现:每个Thread都持有一个TreadLocalMap类型的变量(该类是一个轻量级的Map,功能与map一样,区别是桶里放的是entry而不是entry的链表。功能还是一个map。)以本身为key,以目标为value。主要方法是get()和set(T a),set之后在map里维护一个threadLocal -> a,get时将a返回。ThreadLocal是一个特殊的容器。2.原子类(AtomicInteger、AtomicBoolean……) 如果使用atomic wrapper class如atomicInteger,或者使用自己保证原子的操作,则等同于synchronized //返回值为booleanAtomicInteger.compareAndSet(int expect,int update) 该方法可用于实现乐观锁,考虑文中最初提到的如下场景:a给b付款10元,a扣了10元,b要加10元。此时c给b2元,但是b的加十元代码约为:复制代码 if(b.value.compareAndSet(old, value)){ return ;}else{ //try again // if that fails, rollback and log} 复制代码 AtomicReference对于AtomicReference 来讲,也许对象会出现,属性丢失的情况,即oldObject == current,但是oldObject.getPropertyA != current.getPropertyA。这时候,AtomicStampedReference就派上用场了。这也是一个很常用的思路,即加上版本号3.Lock类  lock: 在java.util.concurrent包内。共有三个实现: ReentrantLockReentrantReadWriteLock.ReadLockReentrantReadWriteLock.WriteLock 主要目的是和synchronized一样, 两者都是为了解决同步问题,处理资源争端而产生的技术。功能类似但有一些区别。 区别如下:复制代码 lock更灵活,可以自由定义多把锁的枷锁解锁顺序(synchronized要按照先加的后解顺序)提供多种加锁方案,lock 阻塞式, trylock 无阻塞式, lockInterruptily 可打断式, 还有trylock的带超时时间版本。本质上和监视器锁(即synchronized是一样的)能力越大,责任越大,必须控制好加锁和解锁,否则会导致灾难。和Condition类的结合。性能更高,对比如下图: 复制代码 synchronized和Lock性能对比 ReentrantLock    可重入的意义在于持有锁的线程可以继续持有,并且要释放对等的次数后才真正释放该锁。使用方法是: 1.先new一个实例 static ReentrantLock r=new ReentrantLock(); 2.加锁       r.lock()或r.lockInterruptibly(); 此处也是个不同,后者可被打断。当a线程lock后,b线程阻塞,此时如果是lockInterruptibly,那么在调用b.interrupt()之后,b线程退出阻塞,并放弃对资源的争抢,进入catch块。(如果使用后者,必须throw interruptable exception 或catch)     3.释放锁    r.unlock() 必须做!何为必须做呢,要放在finally里面。以防止异常跳出了正常流程,导致灾难。这里补充一个小知识点,finally是可以信任的:经过测试,哪怕是发生了OutofMemoryError,finally块中的语句执行也能够得到保证。 ReentrantReadWriteLock 可重入读写锁(读写锁的一个实现)   ReentrantReadWriteLock lock = new ReentrantReadWriteLock()  ReadLock r = lock.readLock();  WriteLock w = lock.writeLock(); 两者都有lock,unlock方法。写写,写读互斥;读读不互斥。可以实现并发读的高效线程安全代码4.容器类 这里就讨论比较常用的两个: BlockingQueueConcurrentHashMap BlockingQueue阻塞队列。该类是java.util.concurrent包下的重要类,通过对Queue的学习可以得知,这个queue是单向队列,可以在队列头添加元素和在队尾删除或取出元素。类似于一个管  道,特别适用于先进先出策略的一些应用场景。普通的queue接口主要实现有PriorityQueue(优先队列),有兴趣可以研究 BlockingQueue在队列的基础上添加了多线程协作的功能: BlockingQueue 除了传统的queue功能(表格左边的两列)之外,还提供了阻塞接口put和take,带超时功能的阻塞接口offer和poll。put会在队列满的时候阻塞,直到有空间时被唤醒;take在队 列空的时候阻塞,直到有东西拿的时候才被唤醒。用于生产者-消费者模型尤其好用,堪称神器。 常见的阻塞队列有: ArrayListBlockingQueueLinkedListBlockingQueueDelayQueueSynchronousQueue ConcurrentHashMap高效的线程安全哈希map。请对比hashTable , concurrentHashMap, HashMap5.管理类 管理类的概念比较泛,用于管理线程,本身不是多线程的,但提供了一些机制来利用上述的工具做一些封装。了解到的值得一提的管理类:ThreadPoolExecutor和 JMX框架下的系统级管理类 ThreadMXBeanThreadPoolExecutor如果不了解这个类,应该了解前面提到的ExecutorService,开一个自己的线程池非常方便:复制代码 ExecutorService e = Executors.newCachedThreadPool(); ExecutorService e = Executors.newSingleThreadExecutor(); ExecutorService e = Executors.newFixedThreadPool(3); // 第一种是可变大小线程池,按照任务数来分配线程, // 第二种是单线程池,相当于FixedThreadPool(1) // 第三种是固定大小线程池。 // 然后运行 e.execute(new MyRunnableImpl()); 复制代码 该类内部是通过ThreadPoolExecutor实现的,掌握该类有助于理解线程池的管理,本质上,他们都是ThreadPoolExecutor类的各种实现版本。请参见javadoc: ThreadPoolExecutor参数解释 翻译一下:复制代码 corePoolSize:池内线程初始值与最小值,就算是空闲状态,也会保持该数量线程。maximumPoolSize:线程最大值,线程的增长始终不会超过该值。keepAliveTime:当池内线程数高于corePoolSize时,经过多少时间多余的空闲线程才会被回收。回收前处于wait状态unit:时间单位,可以使用TimeUnit的实例,如TimeUnit.MILLISECONDS workQueue:待入任务(Runnable)的等待场所,该参数主要影响调度策略,如公平与否,是否产生饿死(starving)threadFactory:线程工厂类,有默认实现,如果有自定义的需要则需要自己实现ThreadFactory接口并作为参数传入。 阿里云优惠券地址https://promotion.aliyun.com/ntms/yunparter/invite.html?userCode=nb3paa5b

景凌凯 2019-12-02 01:40:35 0 浏览量 回答数 0

回答

你这个是window下的?如果是我早忘光了。哈。基本上几年前,我就把“线程”这个概念扔掉了。用进程的构造方式,我们可以讨论讨论中间的逻辑问题。问我线程的任何问题,可权当我不会,因为线程的事情,进程都可以做。所谓线程省资源,更高效,那是基于没有考虑线程额外带来的逻辑的空谈。###### 引用来自“中山野鬼”的答案 你这个是window下的?如果是我早忘光了。哈。基本上几年前,我就把“线程”这个概念扔掉了。用进程的构造方式,我们可以讨论讨论中间的逻辑问题。问我线程的任何问题,可权当我不会,因为线程的事情,进程都可以做。所谓线程省资源,更高效,那是基于没有考虑线程额外带来的逻辑的空谈。 不懂就说你不懂又不会死,别在这里误导新手。线程当然比进程轻量,线程能做的事当然很多进程都做不了,而且楼主发的代码是关于互斥体的与多线程没多大关系,互斥体是跨进程的,你即然这么熟悉多进程,看到一个互斥体的代码却扯了一堆不相关的东西? 而且异常退出关线程、进程啥事?调试方法的问题,你告诉楼主调试中断、捕获异常就行了。 ###### 引用来自“ssn6”的答案 引用来自“中山野鬼”的答案 你这个是window下的?如果是我早忘光了。哈。基本上几年前,我就把“线程”这个概念扔掉了。用进程的构造方式,我们可以讨论讨论中间的逻辑问题。问我线程的任何问题,可权当我不会,因为线程的事情,进程都可以做。所谓线程省资源,更高效,那是基于没有考虑线程额外带来的逻辑的空谈。 不懂就说你不懂又不会死,别在这里误导新手。线程当然比进程轻量,线程能做的事当然很多进程都做不了,而且楼主发的代码是关于互斥体的与多线程没多大关系,互斥体是跨进程的,你即然这么熟悉多进程,看到一个互斥体的代码却扯了一堆不相关的东西? 而且异常退出关线程、进程啥事?调试方法的问题,你告诉楼主调试中断、捕获异常就行了。 哈,随便你说懂不懂,“线程比进程轻,”,我倒想问问,这个“轻”是怎么定义的?系统自定义的(当然不是说你本人),还是针对应用效果定义的?或是开发复杂度定义的? “楼主发的代码是关于互斥体的与多线程没多大关系,互斥体是跨进程的,”为了忙个同步问题,扯出“线程”,结果又扯出“进程”你觉得这样的设计思维没有问题,我就没有办法咯。 哈。工程设计,谁对谁错,需要实际做出来给客户检验,当然也包括不停的维护和改良这个系统的程序员来评判。落到我的个人看法上,会让思维和逻辑变的更复杂的系统,我是不参合讨论的。你说我不懂,那我就不懂吧,而且我真心的说我不懂。因为我根本没必要去懂那些把逻辑搞的更杂而会形成更加混乱局面的东西。包括思维方法,和设计工具以及一堆堆没有价值的概念名词,(有么有价值不是我说的哦。是系统的可延展设计和用户感受说的)哈。 ###### 引用来自“中山野鬼”的答案 引用来自“ssn6”的答案 引用来自“中山野鬼”的答案 你这个是window下的?如果是我早忘光了。哈。基本上几年前,我就把“线程”这个概念扔掉了。用进程的构造方式,我们可以讨论讨论中间的逻辑问题。问我线程的任何问题,可权当我不会,因为线程的事情,进程都可以做。所谓线程省资源,更高效,那是基于没有考虑线程额外带来的逻辑的空谈。 不懂就说你不懂又不会死,别在这里误导新手。线程当然比进程轻量,线程能做的事当然很多进程都做不了,而且楼主发的代码是关于互斥体的与多线程没多大关系,互斥体是跨进程的,你即然这么熟悉多进程,看到一个互斥体的代码却扯了一堆不相关的东西? 而且异常退出关线程、进程啥事?调试方法的问题,你告诉楼主调试中断、捕获异常就行了。 哈,随便你说懂不懂,“线程比进程轻,”,我倒想问问,这个“轻”是怎么定义的?系统自定义的(当然不是说你本人),还是针对应用效果定义的?或是开发复杂度定义的? “楼主发的代码是关于互斥体的与多线程没多大关系,互斥体是跨进程的,”为了忙个同步问题,扯出“线程”,结果又扯出“进程”你觉得这样的设计思维没有问题,我就没有办法咯。 哈。工程设计,谁对谁错,需要实际做出来给客户检验,当然也包括不停的维护和改良这个系统的程序员来评判。落到我的个人看法上,会让思维和逻辑变的更复杂的系统,我是不参合讨论的。你说我不懂,那我就不懂吧,而且我真心的说我不懂。因为我根本没必要去懂那些把逻辑搞的更杂而会形成更加混乱局面的东西。包括思维方法,和设计工具以及一堆堆没有价值的概念名词,(有么有价值不是我说的哦。是系统的可延展设计和用户感受说的)哈。 你不是忘光了,你是根本没用过多线程,更不知道多线程是什么东西,你不是不懂你是不懂到令人震惊的地步,可是你又喜欢喷,线程为什么比线程轻量要问我干什么,不懂自已去学习,什么是线程能做的进程不能做的自己去搞清楚,互斥体是跨进程的不是说楼主的代码里扯到了跨进程,他也可以当线程互斥体来用,你说你根本就一个外行,你还死要面子,动不动就写万言书装逼你累不? ######楼主的意思应该是在主线程里面开一个新的线程去完成一个任务,但是任务还没有完成主线程就退出了。如果这这样的话,上面的代码可以完成楼主的需求,可是感觉你这样做没有什么意义啊。######就是在主进程中,每次过来一个连接就创建一个线程执行A函数,第一个线程的A函数执行没问题,第二个线程执行的时候程序就退出了,这个咋看啥原因。###### 引用来自“ssn6”的答案 引用来自“中山野鬼”的答案 引用来自“ssn6”的答案 引用来自“中山野鬼”的答案 你这个是window下的?如果是我早忘光了。哈。基本上几年前,我就把“线程”这个概念扔掉了。用进程的构造方式,我们可以讨论讨论中间的逻辑问题。问我线程的任何问题,可权当我不会,因为线程的事情,进程都可以做。所谓线程省资源,更高效,那是基于没有考虑线程额外带来的逻辑的空谈。 不懂就说你不懂又不会死,别在这里误导新手。线程当然比进程轻量,线程能做的事当然很多进程都做不了,而且楼主发的代码是关于互斥体的与多线程没多大关系,互斥体是跨进程的,你即然这么熟悉多进程,看到一个互斥体的代码却扯了一堆不相关的东西? 而且异常退出关线程、进程啥事?调试方法的问题,你告诉楼主调试中断、捕获异常就行了。 哈,随便你说懂不懂,“线程比进程轻,”,我倒想问问,这个“轻”是怎么定义的?系统自定义的(当然不是说你本人),还是针对应用效果定义的?或是开发复杂度定义的? “楼主发的代码是关于互斥体的与多线程没多大关系,互斥体是跨进程的,”为了忙个同步问题,扯出“线程”,结果又扯出“进程”你觉得这样的设计思维没有问题,我就没有办法咯。 哈。工程设计,谁对谁错,需要实际做出来给客户检验,当然也包括不停的维护和改良这个系统的程序员来评判。落到我的个人看法上,会让思维和逻辑变的更复杂的系统,我是不参合讨论的。你说我不懂,那我就不懂吧,而且我真心的说我不懂。因为我根本没必要去懂那些把逻辑搞的更杂而会形成更加混乱局面的东西。包括思维方法,和设计工具以及一堆堆没有价值的概念名词,(有么有价值不是我说的哦。是系统的可延展设计和用户感受说的)哈。 你不是忘光了,你是根本没用过多线程,更不知道多线程是什么东西,你不是不懂你是不懂到令人震惊的地步,可是你又喜欢喷,线程为什么比线程轻量要问我干什么,不懂自已去学习,什么是线程能做的进程不能做的自己去搞清楚,互斥体是跨进程的不是说楼主的代码里扯到了跨进程,他也可以当线程互斥体来用,你说你根本就一个外行,你还死要面子,动不动就写万言书装逼你累不? 哈。window的线程,10年前就写过。arm的里面的解码算法程序本身也包括三个线程,用于解决arm和dsp处理速度不匹配的问题。你说我不懂线程,我可以去“承认”,你说我没做过线程设计,哈,这个就不行了。我经历的事实是摆在那的,不是你所能否定的。 另外说一句,你仅能肯定而不能否定一个事物,只能证明你并没有完全了解这个事物。等你啥时懂我在说什么了,在和我讨论“线程”的优势吧。 与其我参与楼主的问题,倒不如给楼主额外的建议和思考问题的方法,也即,是否真的要去学习“线程”的设计方法。我建议你,要么直接回复楼主的答案,要么也就设计方法的好坏给楼主建议,与我争懂不懂,哈,很无聊,不和你争,你说什么都是“对的”。 ###### 引用来自“狼来了而已”的答案 楼主的意思应该是在主线程里面开一个新的线程去完成一个任务,但是任务还没有完成主线程就退出了。如果这这样的话,上面的代码可以完成楼主的需求,可是感觉你这样做没有什么意义啊。 加些日志看看,是不是在执行过程中有什么原因或者异常导致程序退出了。

爱吃鱼的程序员 2020-06-05 13:15:23 0 浏览量 回答数 0

问题

运维人员处理云服务器故障方法七七云转载

杨经理 2019-12-01 22:03:10 9677 浏览量 回答数 2

问题

如何快速定位云主机的故障

firstsko 2019-12-01 21:43:10 10637 浏览量 回答数 1

回答

1.字符串转义序列转义字符 描述(在行尾时) 续行符\ 反斜杠符号' 单引号" 双引号a 响铃b 退格(Backspace)e 转义000 空n 换行v 纵向制表符t 横向制表符r 回车f 换页oyy 八进制数yy代表的字符,例如:o12代表换行xyy 十进制数yy代表的字符,例如:x0a代表换行other 其它的字符以普通格式输出 2.字符串格式化 3.操作符 一、算术运算符 注意: 双斜杠 // 除法总是向下取整。 从符点数到整数的转换可能会舍入也可能截断,建议使用math.floor()和math.ceil()明确定义的转换。 Python定义pow(0, 0)和0 ** 0等于1。 二、比较运算符 运算符 描述< 小于<= 小于或等于 大于= 大于或等于== 等于 != 不等于is 判断两个标识符是不是引用自一个对象is not 判断两个标识符是不是引用自不同对象注意: 八个比较运算符优先级相同。 Python允许x < y <= z这样的链式比较,它相当于x < y and y <= z。 复数不能进行大小比较,只能比较是否相等。 三、逻辑运算符 运算符 描述 备注x or y if x is false, then y, elsex x andy if x is false, then x, elsey not x if x is false, then True,elseFalse 注意: or是个短路运算符,它只有在第一个运算数为False时才会计算第二个运算数的值。 and也是个短路运算符,它只有在第一个运算数为True时才会计算第二个运算数的值。 not的优先级比其他类型的运算符低,所以not a == b相当于not (a == b),而 a == not b是错误的。 四、位运算符 运算符 描述 备注x | y 按位或运算符 x ^ y 按位异或运算符 x & y 按位与运算符 x << n 左移动运算符 x >> n 右移动运算符 ~x 按位取反运算符 五、赋值运算符 复合赋值运算符与算术运算符是一一对应的: 六、成员运算符 Python提供了成员运算符,测试一个元素是否在一个序列(Sequence)中。 运算符 描述in 如果在指定的序列中找到值返回True,否则返回False。not in 如果在指定的序列中没有找到值返回True,否则返回False。 4.关键字总结 Python中的关键字包括如下: and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try你想看看有哪些关键字?OK,打开一个终端,就像这样~ long@zhouyl:~$ pythonPython 2.7.3 (default, Jan 2 2013, 16:53:07) [GCC 4.7.2] on linux2Type "help", "copyright", "credits" or "license" for more information. import keywordkeyword.kwlist ['and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'exec', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or', 'pass', 'print', 'raise', 'return', 'try', 'while', 'with', 'yield'] ============================== 华丽的 正文分隔符 ======================================== 看到这些关键字你还能记得多少?你不妨自己一个一个对照想想它的用法,下面是我总结的,我根据前面的学习笔记将上述关键字分为以下几类: 1.判断、循环 对于Python的循环及判断主要包括这些关键字: if elif else for while break continue and or is not in 这几个关键字在前面介绍 if 语法、while语法、for语法以及and...or语法中已有介绍,下面再一笔带过: 1.1 if 语法 if语法与C语言、shell脚本之下的非常类似,最大的区别就是冒号以及严格的缩进,当然这两点也是Python区别于其他语言的地方: if condition1: do something elif condition2: do another thing else: also do something 1.2 while 语法 Python的while语法区别于C、shell下的while除了冒号及缩进之外,还有一点就是while可以携带一个可选的else语句: while condition: do something else: do something 注:else语句是可选的,但是使用while语句时一定要注意判断语句可以跳出! 1.3 for 语法 与while类似,Python的for循环也包括一个可选的else语句(跳出for循环时执行,但是如果是从break语句跳出则不执行else语句块中的代码!),而且for 加上 关键字in就组成了最常见的列表解析用法(以后会写个专门的博客)。 下面是for的一般用法: for i in range(1,10,2): do something if condition: break else: do something for的列表解析用法: for items in list: print items 1.4 and...or 语法 Python的and/or操作与其他语言不同的是它的返回值是参与判断的两个值之一,所以我们可以通过这个特性来实现Python下的 a ? b : c ! 有C语言基础的知道 “ a ? b : c ! ” 语法是判断 a,如果正确则执行b,否则执行 c! 而Python下我们可以这么用:“ a and b or c ”(此方法中必须保证b必须是True值),python自左向右执行此句,先判断a and b :如果a是True值,a and b语句仍需要执行b,而此时b是True值!所以a and b的值是b,而此时a and b or c就变成了b or c,因b是True值,所以b or c的结果也是b;如果a是False值,a and b语句的结果就是a,此时 a and b or c就转化为a or c,因为此时a是 False值,所以不管c是True 还是Flase,a or c的结果就是c!!!捋通逻辑的话,a and b or c 是不是就是Python下的a ? b : c ! 用法? 1.5 is ,not is 和 is not 是Python下判断同一性的关键字,通常用来判断 是 True 、False或者None(Python下的NULL)! 比如 if alue is True : ... (不记得本节的童鞋罚复习:python 学习笔记 2 -- 判断语句) 2.函数、模块、类 对于Python的函数及模块主要包括这些关键字: from import as def pass lambda return class 那么你还能记得它们么?下面简单介绍一下: 2.1 模块 Python的编程通常大量使用标准库中的模块,使用方法就是使用import 、from以及as 关键字。 比如: import sys # 导入sys模块 from sys import argv # 从sys模块中导入argv ,这个在前面介绍脚本传参数时使用到 import cPickle as p # 将cPickle模块导入并在此将它简单命名为p,此后直接可以使用p替代cPickle模块原名,这个在介绍文件输入输出时的存储器中使用到 2.2 函数 Python中定义函数时使用到def关键字,如果你当前不想写入真实的函数操作,可以使用pass关键字指代不做任何操作: def JustAFunction: pass 当然,在需要给函数返回值时就用到了return关键字,这里简单提一下Python下的函数返回值可以是多个(接收返回值时用相应数量的变量接收!)! 此外Python下有个神奇的Lambda函数,它允许你定义单行的最小函数,这是从Lisp中借用来的,可以用在任何需要函数的地方。比如: g = lambda x : x*2 # 定义一个Lambda函数用来计算参数的2倍并返回! print g(2) # 使用时使用lambda函数返回的变量作为这个函数的函数名,括号中带入相应参数即可! (不记得本节的童鞋罚复习:python 学习笔记 4 -- 函数篇) 3.异常 对于Python的异常主要包括这些关键字: try except finally raise 异常这一节还是比较简单的,将可能出现的异常放在 try: 后面的语句块中,使用except关键字捕获一定的异常并在接下来的语句块中做相应操作,而finally中接的是无论出现什么异常总在执行最后做finally: 后面的语句块(比如关闭文件等必要的操作!) raise关键字是在一定的情况下引发异常,通常结合自定义的异常类型使用。 (不记得本节的童鞋罚复习:python 学习笔记 6 -- 异常处理) 4.其他 上面的三类过后,还剩下这些关键字: print del global with assert yield exec 首先print 在前面的笔记或者任何地方你都能见到,所以还是比较熟悉的,此处就不多介绍了!del 关键字在前面的笔记中已有所涉及,比如删除列表中的某项,我们使用 “ del mylist[0] ” 可能这些剩下来的关键字你比较陌生,所以下面来介绍一下: 4.1.global 关键字 当你在函数定义内声明变量的时候,它们与函数外具有相同名称的其他变量没有任何关系,即变量名称对于函数来说是 局部 的。这称为变量的 作用域 。所有变量的作用域是它们被定义的块,从它们的名称被定义的那点开始。 eg. ? 1 2 3 4 5 6 7 8 9 10 11 !/usr/bin/python Filename: func_local.py def func(x): print'x is', x x = 2 print'Changed local x to', x x = 50 func(x) print'x is still', x 运行的结果是这样的:? 1 2 3 4 $ python func_local.py x is 50 # 运行func函数时,先打印x的值,此时带的值是作为参数带入的外部定义的50,所以能正常打印 x=50 Changed local x to 2 # 在func函数中将x赋2,并打印 x is still 50 # 运行完func函数,打印x的值,此时x的值仍然是之前赋给的50,而不是func函数中修改过的2,因为在函数中修改的只是函数内的局部变量 那么为什么我们要在这提到局部变量呢?bingo,聪明的你一下就猜到这个global就是用来定义全局变量的。也就是说如果你想要为一个在函数外定义的变量赋值,那么你就得告诉Python这个变量名不是局部的,而是 全局 的。我们使用global语句完成这一功能。没有global语句,是不可能为定义在函数外的变量赋值的。eg.? 1 2 3 4 5 6 7 8 9 10 11 12 !/usr/bin/python Filename: func_global.py def func(): global x print'x is', x x = 2 print'Changed local x to', x x = 50 func() print'Value of x is', x 运行的结果是这样的:? 1 2 3 4 $ python func_global.py x is 50 Changed global x to 2 Value of x is 2 # global语句被用来声明x是全局的——因此,当我们在函数内把值赋给x的时候,这个变化也反映在我们在主块中使用x的值的时候。 你可以使用同一个global语句指定多个全局变量。例如global x, y, z。 4.2.with 关键字 有一些任务,可能事先需要设置,事后做清理工作。对于这种场景,Python的with语句提供了一种非常方便的处理方式。一个很好的例子是文件处理,你需要获取一个文件句柄,从文件中读取数据,然后关闭文件句柄。如果不用with语句,打开一个文件并读文件的代码如下:? 1 2 3 file = open("/tmp/foo.txt") data = file.read() file.close() 当然这样直接打开有两个问题:一是可能忘记关闭文件句柄;二是文件读取数据发生异常,没有进行任何处理。下面是添加上异常处理的版本:? 1 2 3 4 5 file = open("/tmp/foo.txt") try: data = file.read() finally: file.close() 虽然这段代码运行良好,但是太冗余了。这时候就是with一展身手的时候了。除了有更优雅的语法,with还可以很好的处理上下文环境产生的异常。下面是with版本的代码:? 1 2 with open("/tmp/foo.txt") as file: data = file.read() 这看起来充满魔法,但不仅仅是魔法,Python对with的处理还很聪明。基本思想是with所求值的对象必须有一个__enter__()方法,一个__exit__()方法。with语句的执行逻辑如下:紧跟with后面的语句被求值后,返回对象的__enter__()方法被调用,这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后,将调用前面返回对象的__exit__()方法。 下面例子可以具体说明with如何工作:? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 !/usr/bin/python with_example01.py classSample: def __enter__(self): print"In __enter__()" return"Foo" def __exit__(self, type, value, trace): print"In __exit__()" def get_sample(): returnSample() with get_sample() as sample: print"sample:", sample 运行代码,输出如下? 1 2 3 4 $python with_example01.py In __enter__() # __enter__()方法被执行 sample: Foo # __enter__()方法返回的值 - 这个例子中是"Foo",赋值给变量'sample',执行代码块,打印变量"sample"的值为"Foo" In __exit__() # __exit__()方法被调用 4.3.assert 关键字 assert语句是一种插入调试断点到程序的一种便捷的方式。assert语句用来声明某个条件是真的,当assert语句失败的时候,会引发一AssertionError,所以结合try...except我们就可以处理这样的异常。 mylist # 此时mylist是有三个元素的列表['a', 'b', 'c']assert len(mylist) is not None # 用assert判断列表不为空,正确无返回assert len(mylist) is None # 用assert判断列表为空 Traceback (most recent call last): File "", line 1, in AssertionError # 引发AssertionError异常 4.4.yield 关键字 我们先看一个示例:? 1 2 3 4 5 6 7 8 def fab(max): n, a, b = 0,0,1 whilen < max: yield b # print b a, b = b, a + b n = n + 1 ''' 使用这个函数:? 1 2 3 4 5 6 7 8 forn in fab(5): ... print n ... 1 1 2 3 5 简单地讲,yield 的作用就是把一个函数变成一个 generator(生成器),带有 yield 的函数不再是一个普通函数,Python 解释器会将其视为一个 generator,调用 fab(5) 不会执行 fab 函数,而是返回一个 iterable(可迭代的)对象!在 for 循环执行时,每次循环都会执行 fab 函数内部的代码,执行到 yield b 时,fab 函数就返回一个迭代值,下次迭代时,代码从 yield b 的下一条语句继续执行,而函数的本地变量看起来和上次中断执行前是完全一样的,于是函数继续执行,直到再次遇到 yield。也可以手动调用 fab(5) 的 next() 方法(因为 fab(5) 是一个 generator 对象,该对象具有 next() 方法),这样我们就可以更清楚地看到 fab 的执行流程:? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 f = fab(5) f.next() 1 f.next() 1 f.next() 2 f.next() 3 f.next() 5 f.next() Traceback (most recent call last): File"", line 1, in StopIteration 当函数执行结束时,generator 自动抛出 StopIteration 异常,表示迭代完成。在 for 循环里,无需处理 StopIteration 异常,循环会正常结束。 我们可以得出以下结论:一个带有 yield 的函数就是一个 generator,它和普通函数不同,生成一个 generator 看起来像函数调用,但不会执行任何函数代码,直到对其调用 next()(在 for 循环中会自动调用 next())才开始执行。虽然执行流程仍按函数的流程执行,但每执行到一个 yield 语句就会中断,并返回一个迭代值,下次执行时从 yield 的下一个语句继续执行。看起来就好像一个函数在正常执行的过程中被 yield 中断了数次,每次中断都会通过 yield 返回当前的迭代值。 yield 的好处是显而易见的,把一个函数改写为一个 generator 就获得了迭代能力,比起用类的实例保存状态来计算下一个 next() 的值,不仅代码简洁,而且执行流程异常清晰。 注:如果看完此段你还未明白yield,没问题,因为yield是初学者的一个难点,那么你下一步需要做的就是……看一看下面参考资料中给的关于yield的博文! 4.5.exec 关键字 官方文档对于exec的解释: "This statement supports dynamic execution of Python code."也就是说使用exec可以动态执行Python代码(也可以是文件)。? 1 2 3 4 5 6 7 8 9 10 11 12 13 longer = "print "Hello World ,my name is longer"" # 比如说我们定义了一个字符串 longer 'print "Hello World ,my name is longer"' exec(longer) # 使用exec 动态执行字符串中的代码 Hello World ,my name is longer exec(sayhi) # 使用exec直接打开文件名(指定sayhi,sayhi.py以及"sayhi.py"都会报一定的错,但是我觉得直接带sayhi报错非常典型) Traceback (most recent call last): File"", line 1, in TypeError: exec: arg 1must be a string, file, or code object # python IDE报错,提示exec的第一个参 数必须是一个字符串、文件或者一个代码对象 f = file("sayhi.py") # 使用file打开sayhi.py并创建f实例 exec(f) # 使用exec直接运行文件描述符f,运行正常!! Hi,thisis [''] script 上述给的例子比较简单,注意例子中exec语句的用法和eval_r(), execfile()是不一样的. exec是一个关键字(要不然我怎么会在这里介绍呢~~~), 而eval_r()和execfile()则是内建函数。更多关于exec的使用请详看引用资料或者Google之 在需要在字符中使用特殊字符时,python用反斜杠()转义字符。 原始字符串 有时我们并不想让转义字符生效,我们只想显示字符串原来的意思,这就要用r和R来定义原始字符串。如: print r’tr’ 实际输出为“tr”。 转义字符 描述 (在行尾时) 续行符 反斜杠符号 ’ 单引号 ” 双引号 a 响铃 b 退格(Backspace) e 转义 000 空 n 换行 v 纵向制表符 t 横向制表符 r 回车 f 换页 oyy 八进制数yy代表的字符,例如:o12代表换行 xyy 十进制数yy代表的字符,例如:x0a代表换行 other 其它的字符以普通格式输出

xuning715 2019-12-02 01:10:21 0 浏览量 回答数 0

回答

分布式事务的解决方案有如下几种: 全局消息基于可靠消息服务的分布式事务TCC最大努力通知方案1:全局事务(DTP模型)全局事务基于DTP模型实现。DTP是由X/Open组织提出的一种分布式事务模型——X/Open Distributed Transaction Processing Reference Model。它规定了要实现分布式事务,需要三种角色: AP:Application 应用系统 它就是我们开发的业务系统,在我们开发的过程中,可以使用资源管理器提供的事务接口来实现分布式事务。 TM:Transaction Manager 事务管理器 分布式事务的实现由事务管理器来完成,它会提供分布式事务的操作接口供我们的业务系统调用。这些接口称为TX接口。事务管理器还管理着所有的资源管理器,通过它们提供的XA接口来同一调度这些资源管理器,以实现分布式事务。DTP只是一套实现分布式事务的规范,并没有定义具体如何实现分布式事务,TM可以采用2PC、3PC、Paxos等协议实现分布式事务。RM:Resource Manager 资源管理器 能够提供数据服务的对象都可以是资源管理器,比如:数据库、消息中间件、缓存等。大部分场景下,数据库即为分布式事务中的资源管理器。资源管理器能够提供单数据库的事务能力,它们通过XA接口,将本数据库的提交、回滚等能力提供给事务管理器调用,以帮助事务管理器实现分布式的事务管理。XA是DTP模型定义的接口,用于向事务管理器提供该资源管理器(该数据库)的提交、回滚等能力。DTP只是一套实现分布式事务的规范,RM具体的实现是由数据库厂商来完成的。有没有基于DTP模型的分布式事务中间件?DTP模型有啥优缺点?方案2:基于可靠消息服务的分布式事务这种实现分布式事务的方式需要通过消息中间件来实现。假设有A和B两个系统,分别可以处理任务A和任务B。此时系统A中存在一个业务流程,需要将任务A和任务B在同一个事务中处理。下面来介绍基于消息中间件来实现这种分布式事务。 title 在系统A处理任务A前,首先向消息中间件发送一条消息消息中间件收到后将该条消息持久化,但并不投递。此时下游系统B仍然不知道该条消息的存在。消息中间件持久化成功后,便向系统A返回一个确认应答;系统A收到确认应答后,则可以开始处理任务A;任务A处理完成后,向消息中间件发送Commit请求。该请求发送完成后,对系统A而言,该事务的处理过程就结束了,此时它可以处理别的任务了。 但commit消息可能会在传输途中丢失,从而消息中间件并不会向系统B投递这条消息,从而系统就会出现不一致性。这个问题由消息中间件的事务回查机制完成,下文会介绍。消息中间件收到Commit指令后,便向系统B投递该消息,从而触发任务B的执行;当任务B执行完成后,系统B向消息中间件返回一个确认应答,告诉消息中间件该消息已经成功消费,此时,这个分布式事务完成。上述过程可以得出如下几个结论: 消息中间件扮演者分布式事务协调者的角色。 系统A完成任务A后,到任务B执行完成之间,会存在一定的时间差。在这个时间差内,整个系统处于数据不一致的状态,但这短暂的不一致性是可以接受的,因为经过短暂的时间后,系统又可以保持数据一致性,满足BASE理论。 上述过程中,如果任务A处理失败,那么需要进入回滚流程,如下图所示: title 若系统A在处理任务A时失败,那么就会向消息中间件发送Rollback请求。和发送Commit请求一样,系统A发完之后便可以认为回滚已经完成,它便可以去做其他的事情。消息中间件收到回滚请求后,直接将该消息丢弃,而不投递给系统B,从而不会触发系统B的任务B。此时系统又处于一致性状态,因为任务A和任务B都没有执行。 上面所介绍的Commit和Rollback都属于理想情况,但在实际系统中,Commit和Rollback指令都有可能在传输途中丢失。那么当出现这种情况的时候,消息中间件是如何保证数据一致性呢?——答案就是超时询问机制。 title 系统A除了实现正常的业务流程外,还需提供一个事务询问的接口,供消息中间件调用。当消息中间件收到一条事务型消息后便开始计时,如果到了超时时间也没收到系统A发来的Commit或Rollback指令的话,就会主动调用系统A提供的事务询问接口询问该系统目前的状态。该接口会返回三种结果: 提交 若获得的状态是“提交”,则将该消息投递给系统B。回滚 若获得的状态是“回滚”,则直接将条消息丢弃。处理中 若获得的状态是“处理中”,则继续等待。消息中间件的超时询问机制能够防止上游系统因在传输过程中丢失Commit/Rollback指令而导致的系统不一致情况,而且能降低上游系统的阻塞时间,上游系统只要发出Commit/Rollback指令后便可以处理其他任务,无需等待确认应答。而Commit/Rollback指令丢失的情况通过超时询问机制来弥补,这样大大降低上游系统的阻塞时间,提升系统的并发度。 下面来说一说消息投递过程的可靠性保证。 当上游系统执行完任务并向消息中间件提交了Commit指令后,便可以处理其他任务了,此时它可以认为事务已经完成,接下来消息中间件一定会保证消息被下游系统成功消费掉!那么这是怎么做到的呢?这由消息中间件的投递流程来保证。 消息中间件向下游系统投递完消息后便进入阻塞等待状态,下游系统便立即进行任务的处理,任务处理完成后便向消息中间件返回应答。消息中间件收到确认应答后便认为该事务处理完毕! 如果消息在投递过程中丢失,或消息的确认应答在返回途中丢失,那么消息中间件在等待确认应答超时之后就会重新投递,直到下游消费者返回消费成功响应为止。当然,一般消息中间件可以设置消息重试的次数和时间间隔,比如:当第一次投递失败后,每隔五分钟重试一次,一共重试3次。如果重试3次之后仍然投递失败,那么这条消息就需要人工干预。 title title 有的同学可能要问:消息投递失败后为什么不回滚消息,而是不断尝试重新投递? 这就涉及到整套分布式事务系统的实现成本问题。 我们知道,当系统A将向消息中间件发送Commit指令后,它便去做别的事情了。如果此时消息投递失败,需要回滚的话,就需要让系统A事先提供回滚接口,这无疑增加了额外的开发成本,业务系统的复杂度也将提高。对于一个业务系统的设计目标是,在保证性能的前提下,最大限度地降低系统复杂度,从而能够降低系统的运维成本。 不知大家是否发现,上游系统A向消息中间件提交Commit/Rollback消息采用的是异步方式,也就是当上游系统提交完消息后便可以去做别的事情,接下来提交、回滚就完全交给消息中间件来完成,并且完全信任消息中间件,认为它一定能正确地完成事务的提交或回滚。然而,消息中间件向下游系统投递消息的过程是同步的。也就是消息中间件将消息投递给下游系统后,它会阻塞等待,等下游系统成功处理完任务返回确认应答后才取消阻塞等待。为什么这两者在设计上是不一致的呢? 首先,上游系统和消息中间件之间采用异步通信是为了提高系统并发度。业务系统直接和用户打交道,用户体验尤为重要,因此这种异步通信方式能够极大程度地降低用户等待时间。此外,异步通信相对于同步通信而言,没有了长时间的阻塞等待,因此系统的并发性也大大增加。但异步通信可能会引起Commit/Rollback指令丢失的问题,这就由消息中间件的超时询问机制来弥补。 那么,消息中间件和下游系统之间为什么要采用同步通信呢? 异步能提升系统性能,但随之会增加系统复杂度;而同步虽然降低系统并发度,但实现成本较低。因此,在对并发度要求不是很高的情况下,或者服务器资源较为充裕的情况下,我们可以选择同步来降低系统的复杂度。 我们知道,消息中间件是一个独立于业务系统的第三方中间件,它不和任何业务系统产生直接的耦合,它也不和用户产生直接的关联,它一般部署在独立的服务器集群上,具有良好的可扩展性,所以不必太过于担心它的性能,如果处理速度无法满足我们的要求,可以增加机器来解决。而且,即使消息中间件处理速度有一定的延迟那也是可以接受的,因为前面所介绍的BASE理论就告诉我们了,我们追求的是最终一致性,而非实时一致性,因此消息中间件产生的时延导致事务短暂的不一致是可以接受的。 方案3:最大努力通知(定期校对)最大努力通知也被称为定期校对,其实在方案二中已经包含,这里再单独介绍,主要是为了知识体系的完整性。这种方案也需要消息中间件的参与,其过程如下: title 上游系统在完成任务后,向消息中间件同步地发送一条消息,确保消息中间件成功持久化这条消息,然后上游系统可以去做别的事情了;消息中间件收到消息后负责将该消息同步投递给相应的下游系统,并触发下游系统的任务执行;当下游系统处理成功后,向消息中间件反馈确认应答,消息中间件便可以将该条消息删除,从而该事务完成。上面是一个理想化的过程,但在实际场景中,往往会出现如下几种意外情况: 消息中间件向下游系统投递消息失败上游系统向消息中间件发送消息失败对于第一种情况,消息中间件具有重试机制,我们可以在消息中间件中设置消息的重试次数和重试时间间隔,对于网络不稳定导致的消息投递失败的情况,往往重试几次后消息便可以成功投递,如果超过了重试的上限仍然投递失败,那么消息中间件不再投递该消息,而是记录在失败消息表中,消息中间件需要提供失败消息的查询接口,下游系统会定期查询失败消息,并将其消费,这就是所谓的“定期校对”。 如果重复投递和定期校对都不能解决问题,往往是因为下游系统出现了严重的错误,此时就需要人工干预。 对于第二种情况,需要在上游系统中建立消息重发机制。可以在上游系统建立一张本地消息表,并将 任务处理过程 和 向本地消息表中插入消息 这两个步骤放在一个本地事务中完成。如果向本地消息表插入消息失败,那么就会触发回滚,之前的任务处理结果就会被取消。如果这量步都执行成功,那么该本地事务就完成了。接下来会有一个专门的消息发送者不断地发送本地消息表中的消息,如果发送失败它会返回重试。当然,也要给消息发送者设置重试的上限,一般而言,达到重试上限仍然发送失败,那就意味着消息中间件出现严重的问题,此时也只有人工干预才能解决问题。 对于不支持事务型消息的消息中间件,如果要实现分布式事务的话,就可以采用这种方式。它能够通过重试机制+定期校对实现分布式事务,但相比于第二种方案,它达到数据一致性的周期较长,而且还需要在上游系统中实现消息重试发布机制,以确保消息成功发布给消息中间件,这无疑增加了业务系统的开发成本,使得业务系统不够纯粹,并且这些额外的业务逻辑无疑会占用业务系统的硬件资源,从而影响性能。 因此,尽量选择支持事务型消息的消息中间件来实现分布式事务,如RocketMQ。 方案4:TCC(两阶段型、补偿型)TCC即为Try Confirm Cancel,它属于补偿型分布式事务。顾名思义,TCC实现分布式事务一共有三个步骤: Try:尝试待执行的业务 这个过程并未执行业务,只是完成所有业务的一致性检查,并预留好执行所需的全部资源Confirm:执行业务 这个过程真正开始执行业务,由于Try阶段已经完成了一致性检查,因此本过程直接执行,而不做任何检查。并且在执行的过程中,会使用到Try阶段预留的业务资源。Cancel:取消执行的业务 若业务执行失败,则进入Cancel阶段,它会释放所有占用的业务资源,并回滚Confirm阶段执行的操作。下面以一个转账的例子来解释下TCC实现分布式事务的过程。 假设用户A用他的账户余额给用户B发一个100元的红包,并且余额系统和红包系统是两个独立的系统。 Try 创建一条转账流水,并将流水的状态设为交易中将用户A的账户中扣除100元(预留业务资源)Try成功之后,便进入Confirm阶段Try过程发生任何异常,均进入Cancel阶段Confirm 向B用户的红包账户中增加100元将流水的状态设为交易已完成Confirm过程发生任何异常,均进入Cancel阶段Confirm过程执行成功,则该事务结束Cancel 将用户A的账户增加100元将流水的状态设为交易失败在传统事务机制中,业务逻辑的执行和事务的处理,是在不同的阶段由不同的部件来完成的:业务逻辑部分访问资源实现数据存储,其处理是由业务系统负责;事务处理部分通过协调资源管理器以实现事务管理,其处理由事务管理器来负责。二者没有太多交互的地方,所以,传统事务管理器的事务处理逻辑,仅需要着眼于事务完成(commit/rollback)阶段,而不必关注业务执行阶段。 TCC全局事务必须基于RM本地事务来实现全局事务TCC服务是由Try/Confirm/Cancel业务构成的, 其Try/Confirm/Cancel业务在执行时,会访问资源管理器(Resource Manager,下文简称RM)来存取数据。这些存取操作,必须要参与RM本地事务,以使其更改的数据要么都commit,要么都rollback。 这一点不难理解,考虑一下如下场景: title 假设图中的服务B没有基于RM本地事务(以RDBS为例,可通过设置auto-commit为true来模拟),那么一旦[B:Try]操作中途执行失败,TCC事务框架后续决定回滚全局事务时,该[B:Cancel]则需要判断[B:Try]中哪些操作已经写到DB、哪些操作还没有写到DB:假设[B:Try]业务有5个写库操作,[B:Cancel]业务则需要逐个判断这5个操作是否生效,并将生效的操作执行反向操作。 不幸的是,由于[B:Cancel]业务也有n(0<=n<=5)个反向的写库操作,此时一旦[B:Cancel]也中途出错,则后续的[B:Cancel]执行任务更加繁重。因为,相比第一次[B:Cancel]操作,后续的[B:Cancel]操作还需要判断先前的[B:Cancel]操作的n(0<=n<=5)个写库中哪几个已经执行、哪几个还没有执行,这就涉及到了幂等性问题。而对幂等性的保障,又很可能还需要涉及额外的写库操作,该写库操作又会因为没有RM本地事务的支持而存在类似问题。。。可想而知,如果不基于RM本地事务,TCC事务框架是无法有效的管理TCC全局事务的。 反之,基于RM本地事务的TCC事务,这种情况则会很容易处理:[B:Try]操作中途执行失败,TCC事务框架将其参与RM本地事务直接rollback即可。后续TCC事务框架决定回滚全局事务时,在知道“[B:Try]操作涉及的RM本地事务已经rollback”的情况下,根本无需执行[B:Cancel]操作。 换句话说,基于RM本地事务实现TCC事务框架时,一个TCC型服务的cancel业务要么执行,要么不执行,不需要考虑部分执行的情况。 TCC事务框架应该提供Confirm/Cancel服务的幂等性保障一般认为,服务的幂等性,是指针对同一个服务的多次(n>1)请求和对它的单次(n=1)请求,二者具有相同的副作用。 在TCC事务模型中,Confirm/Cancel业务可能会被重复调用,其原因很多。比如,全局事务在提交/回滚时会调用各TCC服务的Confirm/Cancel业务逻辑。执行这些Confirm/Cancel业务时,可能会出现如网络中断的故障而使得全局事务不能完成。因此,故障恢复机制后续仍然会重新提交/回滚这些未完成的全局事务,这样就会再次调用参与该全局事务的各TCC服务的Confirm/Cancel业务逻辑。 既然Confirm/Cancel业务可能会被多次调用,就需要保障其幂等性。 那么,应该由TCC事务框架来提供幂等性保障?还是应该由业务系统自行来保障幂等性呢? 个人认为,应该是由TCC事务框架来提供幂等性保障。如果仅仅只是极个别服务存在这个问题的话,那么由业务系统来负责也是可以的;然而,这是一类公共问题,毫无疑问,所有TCC服务的Confirm/Cancel业务存在幂等性问题。TCC服务的公共问题应该由TCC事务框架来解决;而且,考虑一下由业务系统来负责幂等性需要考虑的问题,就会发现,这无疑增大了业务系统的复杂度。

1210119897362579 2019-12-02 00:14:25 0 浏览量 回答数 0

问题

【运维必读】在云计算时代,这是系统运维都需要的产品!

驻云科技 2019-12-01 21:09:06 8919 浏览量 回答数 3

回答

根据Google的webcache从bogdan.org.ua发布: 2007年10月18日 首先:从最新的MySQL开始,标题中提供的语法是不可能的。但是,有几种非常简单的方法可以使用现有功能来完成预期的工作。 有3种可能的解决方案:使用INSERT IGNORE,REPLACE或INSERT…ON DUPLICATE KEY UPDATE。 假设我们有一张桌子: CREATE TABLE transcripts ( ensembl_transcript_id varchar(20) NOT NULL, transcript_chrom_start int(10) unsigned NOT NULL, transcript_chrom_end int(10) unsigned NOT NULL, PRIMARY KEY (ensembl_transcript_id) ) ENGINE=InnoDB DEFAULT CHARSET=latin1; 现在,假设我们有一个自动管道从Ensembl导入笔录元数据,并且由于各种原因,该管道在执行的任何步骤都可能会中断。因此,我们需要确保两件事: 重复执行管道不会破坏我们的数据库 重复执行不会因“主键重复”错误而死亡。 方法1:使用REPLACE 很简单: REPLACE INTO transcripts SET ensembl_transcript_id = 'ENSORGT00000000001', transcript_chrom_start = 12345, transcript_chrom_end = 12678; 如果记录存在,它将被覆盖;如果尚不存在,将创建它。但是,对于我们的情况,使用这种方法效率不高:我们不需要覆盖现有记录,只需要跳过它们就可以了。 方法2:使用INSERT IGNORE也很简单: INSERT IGNORE INTO transcripts SET ensembl_transcript_id = 'ENSORGT00000000001', transcript_chrom_start = 12345, transcript_chrom_end = 12678; 在这里,如果数据库中已经存在“ ensembl_transcript_id”,它将被静默跳过(忽略)。(更准确地说,这是MySQL参考手册的引文:“如果使用IGNORE关键字,则在执行INSERT语句时发生的错误将被视为警告。例如,在没有IGNORE的情况下,该行将复制现有的UNIQUE索引或表中的PRIMARY KEY值导致重复键错误,并且语句中止。”。如果记录尚不存在,则将创建该记录。 第二种方法有一些潜在的弱点,包括在发生任何其他问题时不放弃查询(请参见手册)。因此,如果以前没有使用IGNORE关键字进行测试,则应使用它。 方法3:使用INSERT…ON DUPLICATE KEY UPDATE: 第三种选择是使用INSERT … ON DUPLICATE KEY UPDATE 语法,在UPDATE部分中什么都不做,就没有任何意义(空),例如计算0 + 0(Geoffray建议对MySQL优化引擎执行id = id赋值,以忽略此操作)。此方法的优点是它仅忽略重复的键事件,并且在其他错误时仍然中止。 最后通知:这篇文章的灵感来自Xaprb。我还建议您咨询他的其他有关编写灵活的SQL查询的文章。来源:stack overflow

保持可爱mmm 2020-05-08 11:31:22 0 浏览量 回答数 0

回答

一.Lock接口(java.util.concurrent.locks): void lock():获取锁,阻塞方式;如果资源已被其他线程锁定,那么lock将会阻塞直到获取锁,锁阻塞期间不受线程的Interrupt的影响,在获取锁成功后,才会检测线程的interrupt状态,如果interrupt=true,则抛出异常。 unlock():释放锁 tryLock():尝试获取锁,并发环境中"闯入"行为,如果有锁可用,直接获取锁并返回true,否则范围false. lockInterruptibly():尝试获取锁,并支持"中断"请求。与lock的区别时,此方法的开始、结束和执行过程中,都会不断检测线程的interrupt状态,如果线程被中断,则立即抛出异常;而不像lock方法那样只会在获取锁之后才检测。 二.Lock接口实现类 Lock直接实现,只有3个类:ReentrantLock和WriteLock/ReadLock;这三种锁;Lock和java的synchronized(内置锁)的功能一致,均为排他锁. ReentrantLock为重入排他锁,对于同一线程,如果它已经持有了锁,那么将不会再次获取锁,而直接可以使用. ReentrantReadWriteLock并没有继承ReentrantLock,而是一个基于Lock接口的单独实现.它实现了 ReadWriteLock,即读写分离锁,是一种采用锁分离技巧的API. 尽管在API级别ReentrantReadWriteLock和ReentrantLock没有直接继承关系,但是ReentrantReadWriteLock中的ReadLock和WriteLock都具有ReentrantLock的全部语义(简单说,就是把ReentrantLock的代码copy了一下.),即锁的可重入性.WriteLock支持Condition(条件),ReadLock不支持. Lock的实现类中,都包含了2中锁等待策略:公平和非公平;其实他们的实现也非常简单,底层都是使用了queue来维持锁请求顺序.[参考:http://shift-alt-ctrl.iteye.com/blog/1839142] 公平锁,就是任何锁请求,首先将请求加入队列,然后再有队列机制来决定,是阻塞还是分配锁. 非公平,就是允许"闯入",当然公平锁,也无法干扰"闯入",对于任何锁请求,首先检测锁状态是否可用,如果可用直接获取,否则加入队列.. ReentrantLock本质上和synchronized修饰词是同一语义,如果一个线程lock()之后,其他线程进行lock时必须阻塞,直到当前线程的前续线程unlock.[执行lock操作时,将会被队列化(假如在公平模式下),获取lock的线程都将具有前续/后继线程,前续线程就是当前线程之前执行lock操作而阻塞的线程,后继线程就是当前线程之后执行lock操作的线程;那么对于unlock操作就是"解锁"信号的传递,如果当前线程unlock,那么将会触发后继线程被"唤醒",即它因为lock操作阻塞状态被解除.];这是ReentrantLock的基本原理,但是当ReentrantLock在Conditon情况下,事情就变得更加复杂.[参加下述] 三.Condition:锁条件 Condition与Lock形成happen-before关系。Condition将Object的监视器方法(wait,notify,notifyAll)分解成截然不同的对象,以便通过这些对象与任意Lock实现组合。使Lock具有等待“集合”的特性,或者“类型”;Lock替代了synchronized 方法和语句的使用,Condition 替代了 Object 监视器方法的使用。(synchronized + object.wait对应Lock + Condition.await) Condition又称条件队列,为线程提供了一个含义,以便在某种状态条件现在可能为true的其他线程通知它之前,一直挂起该线程。即多个线程,其中一个线程因为某个条件而阻塞,其他线程当“条件”满足时,则“通知”哪些阻塞的线程。这,几乎和object中wait和notify的机制一样。 Condition和wait一样,阻塞时也将原子性的释放锁(间接执行了release()方法)。并挂起线程。Condition必须与Lock形成关系,只有获取lock权限的,才能进行Condition操作。Condition底层基于AQS实现,条件阻塞,将以队列的方式,LockSupport支持。其实现类有ConditionObject,这也是Lock.newCondition()的返回实际类型,在等待 Condition 时,允许发生“虚假唤醒”,这通常作为对基础平台语义的让步。对于大多数应用程序,这带来的实际影响很小,因为 Condition 应该总是在一个循环中被等待,并测试正被等待的状态声明。某个实现可以随意移除可能的虚假唤醒,但建议应用程序程序员总是假定这些虚假唤醒可能发生,因此总是在一个循环中等待。 void await() throws InterruptedException:当前线程阻塞,并原子性释放对象锁。如下条件将触发线程唤醒: 当线程被中断(支持中断响应), 其他线程通过condition.signal()方法,且碰巧选中当前线程唤醒 其他线程通过condition.signalAll()方法 发生虚假唤醒 底层实现,await()方法将当前线程信息添加到Conditon内部维护的"await"线程队列的尾部(此队列的目的就是为singal方法保持亟待唤醒的线程的顺序),然后释放锁(执行tryRelease()方法,注意此处释放锁,仅仅是释放了锁信号,并不是unlock,此时其他线程仍不能获取锁--lock方法阻塞),然后使用LockSupport.park(this)来强制剥夺当前线程执行权限。await方法会校验线程的中断标记。 由此可见,await()方法执行之后,因为已经"归还"了锁信号,那么其他线程此时执行lock方法,将不再阻塞.. void awaitUninterruptibly():阻塞,直到被唤醒。此方法不响应线程中断请求。即当线程被中断时,它将继续等待,直到接收到signal信号(你应该能想到"陷阱"),当最终从此方法返回时,仍然将设置其中断状态。 void signal()/signalAll():唤醒一个/全部await的线程。 对于signal()方法而言,底层实现为,遍历await"线程队列,找出此condition上最先阻塞的线程,并将此阻塞线程unpark.至此为止,我们似乎发现"锁信号"丢失了,因为在线程await时通过tryRelease时释放了一次信号.那么被signal成功的线程,首先执行一次acquire(增加锁信号),然后校验自己是否被interrupted,如果锁信号获取成功且线程状态正常,此时才正常的从await()方法退出.经过这么复杂的分析,终于明白了ReentrantLock + Condition情况下,锁状态变更和线程控制的来龙去脉... Java代码 收藏代码 //////例子: private Lock lock = new ReentrantLock(); private Condition full = lock.newCondition(); private Condition empty = lock.newCondition(); public Object take(){ lock.lock(); try{ while(isEmpty()){ empty.await() } Object o = get() full.signalAll(); return o; }finally{ lock.unlock(); } } public void put(Object o){ lock.lock(); try{ while(isFull()){ full.await(); } put(o); empty.signalAll(); }finally{ lock.unlock(); } } 四.机制 Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构,可以具有差别很大的属性,可以支持多个相关的 Condition 对象。注意,Lock 实例只是普通的对象,其本身可以在 synchronized 语句中作为目标使用。获取 Lock 实例的监视器锁与调用该实例的任何 lock() 方法没有特别的关系。为了避免混淆,建议除了在其自身的实现中之外,决不要以这种方式使用 Lock 实例。 Lock接口具有的方法: void lock():获取锁,阻塞直到获取。 void lockInterruptibly() throws InterrutedException:获取锁,阻塞直到获取成功,支持中断响应。 boolean tryLock():尝试获取锁,返回是否获取的结果。如果碰巧获取成功,则返回true,此时已经持有锁。 boolean tryLock(long time,TimeUnit) throws InterruptedException:尝试获取锁,获取成功返回true,超时时且没有获取锁则返回false。 void unlock():释放锁。约定只有持有锁者才能释放锁,否则抛出异常。 void newCondition():返回绑定到lock的条件。 五.ReadWriteLock ReadWriteLock 维护了一对相关的锁,一个用于只读操作,另一个用于写入操作。只要没有 writer(写锁),读取锁可以由多个 reader 线程同时保持(共享锁)。写入锁是独占的。所有 ReadWriteLock 实现都必须保证 writeLock 操作的内存同步效果也要保持与相关 readLock 的联系。也就是说,成功获取读锁的线程会看到写入锁之前版本所做的所有更新。 与互斥锁相比,读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程(writer 线程)可以修改共享数据,但在许多情况下,任何数量的线程可以同时读取共享数据(reader 线程),读-写锁利用了这一点。从理论上讲,与互斥锁相比,使用读-写锁所允许的并发性增强将带来更大的性能提高。在实践中,只有在多处理器上并且只在访问模式适用于共享数据时,才能完全实现并发性增强。 Lock readLock():返回读锁。 Lock writeLock():返回写锁。 六.ReentrantLock ReentrantLock,重入排它锁,它和synchronized具有相同的语义以及在监视器上具有相同的行为,但是功能更加强大。 ReetrantLock将由最近成功获得锁且还没有释放锁的线程标记为“锁占有者”;当锁没有被线程持有时,调用lock方法将会成功获取锁并返回,如果当前线程为锁持有者,再次调用lock将立即返回。可以使用 isHeldByCurrentThread() 和 getHoldCount() 方法来检查此情况是否发生。 ReentrantLock的构造方法,允许接收一个“公平策略”参数,“公平策略”下,多个线程竞争获取锁时,将会以队列化锁请求者,并将锁授予队列的head。在“非公平策略”下,则不完全保证锁获取的顺序,允许闯入行为(tryLock)。 ReentrantLock基于AQS机制,锁信号量为1,如果信号量为1且当前锁持有者不为自己,则不能获取锁。释放锁时,如果当前锁持有者不是自己,也将抛出“IllegalMonitorStateException”。由此可见,对于ReentrantLock,lock和release方法是需要组合出现。 七.ReentrantReadWriteLock:可重入读写分离锁 重入性 :当前线程可以重新获取相应的“读锁”或者“写锁”,在写入线程保持的所有写入锁都已经释放后,才允许重入reader(读取线程)使用它们。writer线程可以获取读锁,但是reader线程却不能直接获取写锁。 锁降级:重入还允许写入锁降级为读锁,其实现方式为:先获取写入锁,然后获取读取锁,最后释放写入锁。但是读取锁不能升级为写入锁。 Conditon的支持:只有写入锁支持conditon,对于读取锁,newConditon方法直接抛出UnsupportedOperationException。 ReentrantReadWriteLock目前在java api中无直接使用。ReentrantReadWriteLock并没有继承自 ReentrantLock,而是单独重新实现。其内部仍然支持“公平性”“非公平性”策略。 ReentrantReadWriteLock基于AQS,但是AQS只有一个state来表示锁的状态,所以如果一个state表示2种类型的锁状态,它做了一个很简单的策略,“位运算”,将一个int类型的state拆分为2个16位段,左端表示readlock锁引用计数,右端16位表示write锁。在readLock、writeLock进行获取锁或者释放锁时,均是通过有效的位运算和位控制,来达到预期的效果。 八.ReadLock void lock():获取读取锁,伪代码如下: Java代码 收藏代码 //如果当前已经有“写锁”,且持有写锁者不是当前线程(如果是当前线程,则支持写锁,降级为读锁),则获取锁失败 //即任何读锁的获取,必须等待队列中的写锁释放 //c为实际锁引用量(exclusiveCount方法实现为:c & ((1<<16) -1) if (exclusiveCount(c) != 0 &&getExclusiveOwnerThread() != current) return -1; //CAS操作,操作state的左端16位。 if(CAS(c,c + (1<<16))){ return 1; } void unlock():释放read锁,即共享锁,伪代码如下: Java代码 收藏代码 //CAS锁引用 for (;;) { int c = getState(); int nextc = c - (1<<16);//位操作,释放一个锁。 if (compareAndSetState(c, nextc)) return nextc == 0; } 九.WriteLock void lock():获取写入锁,伪代码如下: Java代码 收藏代码 //当前线程 Thread current = Thread.currentThread(); //实际的锁引用state int c = getState(); //右端16位,通过位运算获取“写入锁”的state int w = exclusiveCount(c); //如果有锁引用 if (c != 0) { //且所引用不是自己 if (w == 0 || current != getExclusiveOwnerThread()){ return false; } } //如果写入锁state为0,且CAS成功,则设置state和独占线程信息 if ((w == 0 && writerShouldBlock(current)) ||!compareAndSetState(c, c + acquires)){ return false; } setExclusiveOwnerThread(current); return true; void unlock():释放写入锁,伪代码如下: Java代码 收藏代码 //计算释放锁的信号量 int nextc = getState() - releases; //对于写入锁,则校验当前线程是否为锁持有者,否则不可以释放(死锁) if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); //释放锁,且重置独占线程信息 if (exclusiveCount(nextc) == 0) { setExclusiveOwnerThread(null); setState(nextc); return true; } else { setState(nextc); return false; } 十.LockSupport:用来创建锁和其他同步类的基本线程阻塞原语。 底层基于hotspot的实现unsafe。park 和 unpark 方法提供了阻塞和解除阻塞线程的有效方法。三种形式的 park(即park,parkNanos(Object blocker,long nanos),parkUntil(Object blocker,long timestamp)) 还各自支持一个 blocker 对象参数。此对象在线程受阻塞时被记录,以允许监视工具和诊断工具确定线程受阻塞的原因。(这样的工具可以使用方法 getBlocker(java.lang.Thread) 访问 blocker。)建议最好使用这些形式,而不是不带此参数的原始形式。 在锁实现中提供的作为 blocker 的普通参数是 this。 static void park(Object blocker):阻塞当前线程,直到如下情况发生: 其他线程,调用unpark方法,并将此线程作为目标而唤醒 其他线程中断当前线程此方法不报告,此线程是何种原因被放回,需要调用者重新检测,而且此方法也经常在while循环中执行 Java代码 收藏代码 while(//condition,such as:queue.isEmpty){ LockSupport.park(queue);//此时queue对象作为“阻塞”点传入,以便其他监控工具查看,queue的状态 //检测当前线程是否已经中断。 if(Thread.interrupted()){ break; } } void getBlocker(Thread t):返回提供最近一次尚未解除阻塞的park的阻塞点。可以返回null。 void unpark(Thread t):解除指定线程阻塞,使其可用。参数null则无效果。 LockSupport实例(不过不建议在实际代码中直接使用LockSupport,很多时候,你可以使用锁来控制): Java代码 收藏代码 /////////////Demo public class LockSupportTestMain { /** * @param args */ public static void main(String[] args) throws Exception{ System.out.println("Hear!"); BlockerObject blocker = new BlockerObject(); LThread tp = new LThread(blocker, false); LThread tt = new LThread(blocker, true); tp.start(); tt.start(); Thread.sleep(1000); } static class LThread extends Thread{ private BlockerObject blocker; boolean take; LThread(BlockerObject blocker,boolean take){ this.blocker = blocker; this.take = take; } @Override public void run(){ if(take){ while(true){ Object o = blocker.take(); if(o != null){ System.out.println(o.toString()); } } }else{ Object o = new Object(); System.out.println("put,,," + o.toString()); blocker.put(o); } } } static class BlockerObject{ Queue<Object> inner = new LinkedList<Object>(); Queue<Thread> twaiters = new LinkedList<Thread>(); Queue<Thread> pwaiters = new LinkedList<Thread>(); public void put(Object o){ inner.offer(o); pwaiters.offer(Thread.currentThread()); Thread t = twaiters.poll(); if(t != null){ LockSupport.unpark(t); } System.out.println("park"); LockSupport.park(Thread.currentThread()); System.out.println("park is over"); } public Object take(){ Thread t = pwaiters.poll(); if(t != null){ System.out.println("unpark"); LockSupport.unpark(t); System.out.println("unpark is OK"); } //twaiters.offer(Thread.currentThread()); return inner.poll(); } } } 备注:有时候会疑惑wait()/notify() 和Unsafe.park()/unpark()有什么区别?区别是wait和notify是Object类的方法,它们首选需要获得“对象锁”,并在synchronized同步快中执行。park和unpark怎不需要这么做。wait和park都是有当前线程发起,notify和unpark都是其他线程发起。wait针对的是对象锁,park针对的线程本身,但是最终的效果都是导致当前线程阻塞。Unsafe不建议开发者直接使用。

景凌凯 2020-04-24 16:41:16 0 浏览量 回答数 0

问题

荆门开诊断证明-scc

游客5k2abgdj3m2ti 2019-12-01 22:09:00 1 浏览量 回答数 0

问题

健康检查常见问题

行者武松 2019-12-01 21:43:15 3573 浏览量 回答数 0

问题

【精品问答】Java技术1000问(1)

问问小秘 2019-12-01 21:57:43 39155 浏览量 回答数 15

回答

参考:https://www.iteblog.com/archives/2530.html分布式和去中心化(Distributed and Decentralized)Cassandra 是分布式的,这意味着它可以运行在多台机器上,并呈现给用户一个一致的整体。事实上,在一个节点上运行 Cassandra 是没啥用的,虽然我们可以这么做,并且这可以帮助我们了解它的工作机制,但是你很快就会意识到,需要多个节点才能真正了解 Cassandra 的强大之处。它的很多设计和实现让系统不仅可以在多个节点上运行,更为多机架部署进行了优化,甚至一个 Cassandra 集群可以运行在分散于世界各地的数据中心上。你可以放心地将数据写到集群的任意一台机器上,Cassandra 都会收到数据。对于很多存储系统(比如 MySQL, Bigtable),一旦你开始扩展它,就需要把某些节点设为主节点,其他则作为从节点。但 Cassandra 是无中心的,也就是说每个节点都是一样的。与主从结构相反,Cassandra 的协议是 P2P 的,并使用 gossip 来维护存活或死亡节点的列表。关于 gossip 可以参见《分布式原理:一文了解 Gossip 协议》。去中心化这一事实意味着 Cassandra 不会存在单点失效。Cassandra 集群中的所有节点的功能都完全一样, 所以不存在一个特殊的主机作为主节点来承担协调任务。有时这被叫做服务器对称(server symmetry)。综上所述,Cassandra 是分布式、无中心的,它不会有单点失效,所以支持高可用性。弹性可扩展(Elastic Scalability)可扩展性是指系统架构可以让系统提供更多的服务而不降低使用性能的特性。仅仅通过给现有的机器增加硬件的容量、内存进行垂直扩展,是最简单的达到可扩展性的手段。而水平扩展则需要增加更多机器,每台机器提供全部或部分数据,这样所有主机都不必负担全部业务请求。但软件自己需要有内部机制来保证集群中节点间的数据同步。弹性可扩展是指水平扩展的特性,意即你的集群可以不间断的情况下,方便扩展或缩减服务的规模。这样,你就不需要重新启动进程,不必修改应用的查询,也无需自己手工重新均衡数据分布。在 Cassandra 里,你只要加入新的计算机,Cassandra 就会自动地发现它并让它开始工作。高可用和容错(High Availability and Fault Tolerance)从一般架构的角度来看,系统的可用性是由满足请求的能力来量度的。但计算机可能会有各种各样的故障,从硬件器件故障到网络中断都有可能。如何计算机都可能发生这些情况,所以它们一般都有硬件冗余,并在发生故障事件的情况下会自动响应并进行热切换。对一个需要高可用的系统,它必须由多台联网的计算机构成,并且运行于其上的软件也必须能够在集群条件下工作,有设备能够识别节点故障,并将发生故障的中端的功能在剩余系统上进行恢复。Cassandra 就是高可用的。你可以在不中断系统的情况下替换故障节点,还可以把数据分布到多个数据中心里,从而提供更好的本地访问性能,并且在某一数据中心发生火灾、洪水等不可抗灾难的时候防止系统彻底瘫痪。可调节的一致性(Tuneable Consistency)2000年,加州大学伯克利分校的 Eric Brewer 在 ACM 分布式计算原理会议提出了著名的 CAP 定律。CAP 定律表明,对于任意给定的系统,只能在一致性(Consistency)、可用性(Availability)以及分区容错性(Partition Tolerance)之间选择两个。关于 CAP 定律的详细介绍可参见《分布式系统一致性问题、CAP定律以及 BASE 理论》以及《一篇文章搞清楚什么是分布式系统 CAP 定理》。所以 Cassandra 在设计的时候也不得不考虑这些问题,因为分区容错性这个是每个分布式系统必须考虑的,所以只能在一致性和可用性之间做选择,而 Cassandra 的应用场景更多的是为了满足可用性,所以我们只能牺牲一致性了。但是根据 BASE 理论,我们其实可以通过牺牲强一致性获得可用性。Cassandra 提供了可调节的一致性,允许我们选定需要的一致性水平与可用性水平,在二者间找到平衡点。因为客户端可以控制在更新到达多少个副本之前,必须阻塞系统。这是通过设置副本因子(replication factor)来调节与之相对的一致性级别。通过副本因子(replication factor),你可以决定准备牺牲多少性能来换取一致性。 副本因子是你要求更新在集群中传播到的节点数(注意,更新包括所有增加、删除和更新操作)。客户端每次操作还必须设置一个一致性级别(consistency level)参数,这个参数决定了多少个副本写入成功才可以认定写操作是成功的,或者读取过程中读到多少个副本正确就可以认定是读成功的。这里 Cassandra 把决定一致性程度的权利留给了客户自己。所以,如果需要的话,你可以设定一致性级别和副本因子相等,从而达到一个较高的一致性水平,不过这样就必须付出同步阻塞操作的代价,只有所有节点都被更新完成才能成功返回一次更新。而实际上,Cassandra 一般都不会这么来用,原因显而易见(这样就丧失了可用性目标,影响性能,而且这不是你选择 Cassandra 的初衷)。而如果一个客户端设置一致性级别低于副本因子的话,即使有节点宕机了,仍然可以写成功。总体来说,Cassandra 更倾向于 CP,虽然它也可以通过调节一致性水平达到 AP;但是不推荐你这么设置。面向行(Row-Oriented)Cassandra 经常被看做是一种面向列(Column-Oriented)的数据库,这也并不算错。它的数据结构不是关系型的,而是一个多维稀疏哈希表。稀疏(Sparse)意味着任何一行都可能会有一列或者几列,但每行都不一定(像关系模型那样)和其他行有一样的列。每行都有一个唯一的键值,用于进行数据访问。所以,更确切地说,应该把 Cassandra 看做是一个有索引的、面向行的存储系统。Cassandra 的数据存储结构基本可以看做是一个多维哈希表。这意味着你不必事先精确地决定你的具体数据结构或是你的记录应该包含哪些具体字段。这特别适合处于草创阶段,还在不断增加或修改服务特性的应用。而且也特别适合应用在敏捷开发项目中,不必进行长达数月的预先分析。对于使用 Cassandra 的应用,如果业务发生变化了,只需要在运行中增加或删除某些字段就行了,不会造成服务中断。当然, 这不是说你不需要考虑数据。相反,Cassandra 需要你换个角度看数据。在 RDBMS 里, 你得首先设计一个完整的数据模型, 然后考虑查询方式, 而在 Cassandra 里,你可以首先思考如何查询数据,然后提供这些数据就可以了。灵活的模式(Flexible Schema)Cassandra 的早期版本支持无模式(schema-free)数据模型,可以动态定义新的列。 无模式数据库(如 Bigtable 和 MongoDB)在访问大量数据时具有高度可扩展性和高性能的优势。 无模式数据库的主要缺点是难以确定数据的含义和格式,这限制了执行复杂查询的能力。为了解决这些问题,Cassandra 引入了 Cassandra Query Language(CQL),它提供了一种通过类似于结构化查询语言(SQL)的语法来定义模式。 最初,CQL 是作为 Cassandra 的另一个接口,并且基于 Apache Thrift 项目提供无模式的接口。 在这个过渡阶段,术语“模式可选”(Schema-optional)用于描述数据模型,我们可以使用 CQL 的模式来定义。并且可以通过 Thrift API 实现动态扩展以此添加新的列。 在此期间,基础数据存储模型是基于 Bigtable 的。从 3.0 版本开始,不推荐使用基于 Thrift API 的动态列创建的 API,并且 Cassandra 底层存储已经重新实现了,以更紧密地与 CQL 保持一致。 Cassandra 并没有完全限制动态扩展架构的能力,但它的工作方式却截然不同。 CQL 集合(比如 list、set、尤其是 map)提供了在无结构化的格式里面添加内容的能力,从而能扩展现有的模式。CQL 还提供了改变列的类型的能力,以支持 JSON 格式的文本的存储。因此,描述 Cassandra 当前状态的最佳方式可能是它支持灵活的模式。高性能(High Performance)Cassandra 在设计之初就特别考虑了要充分利用多处理器和多核计算机的性能,并考虑在分布于多个数据中心的大量这类服务器上运行。它可以一致而且无缝地扩展到数百台机器,存储数 TB 的数据。Cassandra 已经显示出了高负载下的良好表现,在一个非常普通的工作站上,Cassandra 也可以提供非常高的写吞吐量。而如果你增加更多的服务器,你还可以继续保持 Cassandra 所有的特性而无需牺牲性能。

封神 2019-12-02 02:00:50 0 浏览量 回答数 0

回答

没有一个初步的战略 大多数没有计算机科学或数据分析背景的工程师想要在数据科学中开始一个新的职业生涯,他们没有一个明确的战略,没有成为数据科学家、分析师或工程师的明确步骤。他们试图尽可能快地用信息填满自己的脑袋,而不是真正深入到特定的主题;他们倾向于一次注册多个在线课程,从不同的网站下载几个备忘单,阅读许多作者的文章,但没有一个结构化的计划。在开始这段旅程之前,我强烈建议你制定一个学习计划,并列出一些日常习惯,以实现你的目标,增强你的分析和编程技能。对你想从事的行业使用的最流行的编程语言和软件进行自己的研究,搜索最广泛使用的库和包,并根据你的目标选择最适合你的编程语言和软件。坚持和练习会使你成为大师。 尝试同时学习几种编程语言和软件 新程序员常常会受到诱惑,想要同时学习几种编程语言和软件,把它们作为技术技能写进简历。虽然你可能认为这是一种营销自己的策略,但它往往会适得其反。拥有数据科学、数据分析师和数据工程职位的公司和组织更有可能要求应聘者具备一种或两种或最多三种编程语言和软件的坚实背景。很少有职位要求你同时精通Python, R, SQL, C, c , c#, Matlab, Java, Ruby。相反,你应该研究一下你更可能在某个特定行业或公司使用的编程语言和软件;掌握你的编程和分析技能,并成为真正的专家。你将认识到,所有编程语言之间共享一个公共逻辑和类似的函数,在此之后,从一种语言到另一种语言的转换只需要学习一种不同的语法,而不需要学习它背后的整个逻辑。 没有在代码上写注释 尽管这听起来很明显,而且是一个无关紧要的任务,但它代表了一种很好的策略,可以跟踪每一行或每一块代码执行的操作,以便返回到暂停的项目。在最初的代码编写过程中,程序员对项目的目的和目标有了清晰而清晰的认识;他们知道自己想要编写的程序背后的逻辑步骤和追求的结果。然而,由于多种原因(经济约束、信息缺失、优先级的改变),所有的项目都很容易暂停,这将迫使程序员切换到不同的任务,而让先前的任务保持不变。一个中断的项目需要的时间越长,就越不容易记住它的位置和缺失的点。这里是注释发挥作用的地方。试着在你认为有必要的地方使用它们;记住要足够清晰,并记住它们应该允许代码程序员和执行者理解代码背后的逻辑步骤。 在代码编写过程中不要求反馈 在你的经理要求你做什么,他/她希望你做什么,客户要求什么,和你实际做什么之间总是有很大的差距。当你在开发一个程序或新代码时,试着把它分成几个阶段,并在进入下一个阶段之前征求反馈。在每个阶段结束后得到反馈,这将让你知道你是否正确,或者是否需要根据客户的要求进行更改。这并不意味着你无法理解其他人的要求,而是将其视为利益相关者之间的想法和期望的统一。如果在偏离正轨的情况下,你收到反馈的频率越高,你需要进行的修改就越少。请记住,持续的沟通对于每一个项目的成功实施都是至关重要的。 没有测试你当前的知识 你可能已经看了很多逐步编程教程。你可能也读过许多数据科学书籍和编程书。你可能已经完成了许多编程训练营的练习。下一步是什么?测试你目前的知识。这种训练营和课程的真正价值不在于证书本身,而在于你学到的知识,并能成功地应用于解决某个问题。老实说,每个人都可以通过参加在线课程来获得证书,只要跳过大部分的课程就可以了;公司和组织都非常清楚这一点。尝试把自己推向新的极限,在网上寻找编程挑战,尝试头脑风暴,在没有太多帮助资源的情况下编写代码。这并不意味着你在实际工作中不会用到它们,但它会让你感觉更舒服,更安全,更少依赖它们。 没有充分利用优缺点 在某种程度上,你可能会觉得使用一种特定的编程语言和软件是很舒服的,而你可能会发现学习一种新的语言和软件是没有用的。我曾多次听到数据分析师争论哪种编程语言在能力、可用库和包、在线资源和流行程度方面是最好的。但是,你必须足够谦虚,认识到总有从另一种语言、库、包或软件中学习新东西的空间。每种编程语言和软件都有其优点和缺点,但是我们的目标是充分利用它们,并具有足够的灵活性,以确定最适合用于特定任务以解决特定问题的语言和软件。 假设你什么都知道 相信我,没有人什么都知道。数据科学领域非常广泛,每天都要学习新东西。库、包、函数、方法和算法的总数非常多。永远保持好奇,保持谦虚,如果你认为你知道的很多,你实际知道的就很少。 原文链接: https://blog.csdn.net/fendouaini/article/details/103252444

茶什i 2020-01-15 11:57:21 0 浏览量 回答数 0

问题

性能测试:软件测试的重中之重

云效平台 2019-12-01 21:45:09 5839 浏览量 回答数 1

回答

没有一个初步的战略 大多数没有计算机科学或数据分析背景的工程师想要在数据科学中开始一个新的职业生涯,他们没有一个明确的战略,没有成为数据科学家、分析师或工程师的明确步骤。他们试图尽可能快地用信息填满自己的脑袋,而不是真正深入到特定的主题;他们倾向于一次注册多个在线课程,从不同的网站下载几个备忘单,阅读许多作者的文章,但没有一个结构化的计划。在开始这段旅程之前,我强烈建议你制定一个学习计划,并列出一些日常习惯,以实现你的目标,增强你的分析和编程技能。对你想从事的行业使用的最流行的编程语言和软件进行自己的研究,搜索最广泛使用的库和包,并根据你的目标选择最适合你的编程语言和软件。坚持和练习会使你成为大师。 尝试同时学习几种编程语言和软件 新程序员常常会受到诱惑,想要同时学习几种编程语言和软件,把它们作为技术技能写进简历。虽然你可能认为这是一种营销自己的策略,但它往往会适得其反。拥有数据科学、数据分析师和数据工程职位的公司和组织更有可能要求应聘者具备一种或两种或最多三种编程语言和软件的坚实背景。很少有职位要求你同时精通Python, R, SQL, C, c , c#, Matlab, Java, Ruby。相反,你应该研究一下你更可能在某个特定行业或公司使用的编程语言和软件;掌握你的编程和分析技能,并成为真正的专家。你将认识到,所有编程语言之间共享一个公共逻辑和类似的函数,在此之后,从一种语言到另一种语言的转换只需要学习一种不同的语法,而不需要学习它背后的整个逻辑。 3.没有在代码上写注释 尽管这听起来很明显,而且是一个无关紧要的任务,但它代表了一种很好的策略,可以跟踪每一行或每一块代码执行的操作,以便返回到暂停的项目。在最初的代码编写过程中,程序员对项目的目的和目标有了清晰而清晰的认识;他们知道自己想要编写的程序背后的逻辑步骤和追求的结果。然而,由于多种原因(经济约束、信息缺失、优先级的改变),所有的项目都很容易暂停,这将迫使程序员切换到不同的任务,而让先前的任务保持不变。一个中断的项目需要的时间越长,就越不容易记住它的位置和缺失的点。这里是注释发挥作用的地方。试着在你认为有必要的地方使用它们;记住要足够清晰,并记住它们应该允许代码程序员和执行者理解代码背后的逻辑步骤。 在代码编写过程中不要求反馈 在你的经理要求你做什么,他/她希望你做什么,客户要求什么,和你实际做什么之间总是有很大的差距。当你在开发一个程序或新代码时,试着把它分成几个阶段,并在进入下一个阶段之前征求反馈。在每个阶段结束后得到反馈,这将让你知道你是否正确,或者是否需要根据客户的要求进行更改。这并不意味着你无法理解其他人的要求,而是将其视为利益相关者之间的想法和期望的统一。如果在偏离正轨的情况下,你收到反馈的频率越高,你需要进行的修改就越少。请记住,持续的沟通对于每一个项目的成功实施都是至关重要的。 没有测试你当前的知识 你可能已经看了很多逐步编程教程。你可能也读过许多数据科学书籍和编程书。你可能已经完成了许多编程训练营的练习。下一步是什么?测试你目前的知识。这种训练营和课程的真正价值不在于证书本身,而在于你学到的知识,并能成功地应用于解决某个问题。老实说,每个人都可以通过参加在线课程来获得证书,只要跳过大部分的课程就可以了;公司和组织都非常清楚这一点。尝试把自己推向新的极限,在网上寻找编程挑战,尝试头脑风暴,在没有太多帮助资源的情况下编写代码。这并不意味着你在实际工作中不会用到它们,但它会让你感觉更舒服,更安全,更少依赖它们。 没有充分利用优缺点 在某种程度上,你可能会觉得使用一种特定的编程语言和软件是很舒服的,而你可能会发现学习一种新的语言和软件是没有用的。我曾多次听到数据分析师争论哪种编程语言在能力、可用库和包、在线资源和流行程度方面是最好的。但是,你必须足够谦虚,认识到总有从另一种语言、库、包或软件中学习新东西的空间。每种编程语言和软件都有其优点和缺点,但是我们的目标是充分利用它们,并具有足够的灵活性,以确定最适合用于特定任务以解决特定问题的语言和软件。 假设你什么都知道 相信我,没有人什么都知道。数据科学领域非常广泛,每天都要学习新东西。库、包、函数、方法和算法的总数非常多。永远保持好奇,保持谦虚,如果你认为你知道的很多,你实际知道的就很少。 ———————————————— 版权声明:本文为CSDN博主「磐创 AI」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明。 原文链接:https://blog.csdn.net/fendouaini/article/details/103252444

jiewuyu 2020-01-15 10:01:22 0 浏览量 回答数 0

问题

对症下药:Tomcat停机过程分析与线程处理方法

驻云科技 2019-12-01 21:36:46 4001 浏览量 回答数 0

回答

Change Stream即变更流,是MongoDB向应用发布数据变更的一种方式。即当数据库中有任何数据发生变化,应用端都可以得到通知。我们可以将其理解为在应用中执行的触发器。至于应用想得到什么数据,以什么形式得到数据,则可以通过聚合框架加以过滤和转换。这点将在后文中讨论。  Change Stream 的原理  我们先来回顾一下MongoDB复制集大致是如何工作的: 应用通过驱动向数据库发起写入请求; 在同一个事务中,MongoDB完成oplog和集合的修改; oplog被其他从节点拉走; 从节点应用得到的oplog,同样在一个事务中完成对oplog和集合的修改; 至此,复制集同步完成。可以发现,整个同步过程是依赖于oplog来进行的。也就是说oplog实际上已经包含了我们需要的所有变更数据。如果观测oplog的变化,是否就能够得到所有变更的数据了呢?对,change stream正是基于这个原理实现的。但事情并没有这么简单!我们来看一下问题有可能出在什么地方。 如何从断点恢复 现实世界中,没有哪个应用是可以不间断运行的。不考虑bug导致的问题,正常的应用升级也会导致应用中断运行。那么在应用恢复的时候,从哪里开始继续获取变更呢?oplog当然是可以帮我们做到这点的,但你必须对MongoDB足够了解,才知道有oplogReplay这样的参数,以及其他一些问题。 如何有效地处理订阅 假设在一个应用中需要订阅10个不同集合的变更情况,是否需要开10个tailable cursor去获取oplog的变更呢?如果是100个集合呢?出于效率考虑显然不应该这么做。那么整个过程就会变成一个生产者-消费者模式,由一个线程负责从oplog获取变更,由订阅的线程负责消费这些变更。虽然实现也不是那么复杂,并且多半可以找到开源实现,但是涉及多线程就已经足够让初学者头疼一阵的了。 公平地说,上面这些还不算严重的问题,下面这些问题可能会更让人头疼。 如何管理权限 想要tail oplog,必须对local.oplog.rs有读权限。实际上这相当于对整个数据库都有了读权限,因为所有的变更都会在这里体现出来。DBA可能会阻止你这么做,因为这实在不是一个很安全的做法。 如何数据回滚 极端情况下,如果应用处理不当,MongoDB中可能发生数据回滚rollback的问题。如果仅仅通过跟踪oplog,则会出现已经通知出去的变更被回滚的情况。 幸运的是上面这些问题现在都不是问题了,因为change stream帮我们规避了这些复杂的细节。 使用方法 由于各种驱动都会有不同的语法和API,从shell中尝试使用change stream可能是最简便的方法。这并不妨碍你随后在各种驱动中的使用,因为shell中能实现的功能在驱动中一定有对应的语法。下面就以shell为例看看change stream应该如何使用。 打开一个shell,订阅你需要关注的集合 比如: var cursor = db.bar.watch(); 为了便于演示,我们在这个shell中不断遍历这个游标以获取新数据: while(true) {    if (cursor.hasNext()) {        print(JSON.stringify(cursor.next()));    } } 打开另一个shell,向bar集合中插入一条数据: db.bar.insert({y: 1}) 此时第一个shell中会立即输出变更数据: {"_id":{"_data": {"$binary":"glzquiIAAAACRmRfaWQAZFzquiK0lDNo+K0DpwBaEARUMrm0ruVACoftuxjt1RtCBA==","$type":"00"}}, "operationType":"insert","fullDocument":{"_id":{"$oid":"5ceaba22b4943368f8ad03a7"},"y":1},"ns": {"db":"test","coll":"bar"},"documentKey":{"_id":{"$oid":"5ceaba22b4943368f8ad03a7"}}} 这里的一些字段的简单介绍。更完整的介绍请查阅文档change events: _id: 用于恢复断点时使用。即知道这个值,应用断开后下次重启里就可以从这个断点之后开始恢复获得变更; operationType: 操作类型,常见的值包括: insert update delete ns: 正在操作的命名空间 fullDocument: 完整的文档 从断点恢复 var cursor = db.bar.watch([], {resumeAfter: <_id>}) 此时使用hasNext()/next()即可获取到随后的变更。

1748847708358317 2019-12-02 03:11:13 0 浏览量 回答数 0

问题

怎样实现数据存储的管理维护

elinks 2019-12-01 21:14:17 9098 浏览量 回答数 0

问题

服务器急救

fuwuqi1 2019-12-01 21:29:02 1556 浏览量 回答数 1

问题

【Java学习全家桶】1460道Java热门问题,阿里百位技术专家答疑解惑

管理贝贝 2019-12-01 20:07:15 27612 浏览量 回答数 19

问题

为什么无法连接Windows实例

boxti 2019-12-01 21:47:52 1892 浏览量 回答数 0

问题

模板,从服务端到客户端

go696 2019-12-01 21:32:31 3535 浏览量 回答数 0

问题

在服务器上排除问题的头五分钟

五弊三缺 2019-12-01 21:41:11 9114 浏览量 回答数 1
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站 阿里云双十一主会场 阿里云双十一新人会场 1024程序员加油包 阿里云双十一拼团会场 场景化解决方案 阿里云双十一直播大厅