• 关于

    __call()方法的应用

    的搜索结果

问题

将列添加到mysql表(如果不存在)

保持可爱mmm 2020-05-11 13:45:09 0 浏览量 回答数 1

问题

C-SDK之如何实现上传文件(四)?

青衫无名 2019-12-01 21:45:55 1048 浏览量 回答数 0

回答

当我可以在60秒内在类似硬件上执行相同操作时,您的查询要花2个小时才能执行,这是一件非常错误的事情。 以下某些内容可能会有所帮助... 为您的引擎调整MySQL 检查服务器配置并进行相应优化。以下某些资源应该是有用的。 http://www.mysqlperformanceblog.com/2006/09/29/what-to-tune-in-mysql-server-after-installation/ http://www.mysqlperformanceblog.com/ http://www.highperfmysql.com/ http://forge.mysql.com/wiki/ServerVariables http://dev.mysql.com/doc/refman/5.0/en/server-system-variables.html http://www.xaprb.com/blog/2006/07/04/how-to-exploit-mysql-index-optimizations/ http://jpipes.com/presentations/perf_tuning_best_practices.pdf http://jpipes.com/presentations/index_coding_optimization.pdf http://www.jasny.net/?p=36 现在不那么明显了... 考虑使用存储过程来处理数据服务器端 为什么不处理MySQL内部的所有数据,从而不必将大量数据发送到应用程序层?以下示例使用游标在2分钟内循环和处理服务器端5000万行。我不是游标的忠实拥护者,尤其是在MySQL游标非常有限的地方,但是我猜想您会循环结果集并进行某种形式的数值分析,因此在这种情况下使用游标是合理的。 简化的myisam结果表-基于您的密钥。 drop table if exists results_1mregr_c_ew_f; create table results_1mregr_c_ew_f ( id int unsigned not null auto_increment primary key, rc tinyint unsigned not null, df int unsigned not null default 0, val double(10,4) not null default 0, ts timestamp not null default now(), key (rc, df) ) engine=myisam; 我生成了1亿行数据,其中关键字段的基数与您的示例大致相同: show indexes from results_1mregr_c_ew_f; Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Index_type ===== ========== ======== ============ =========== ========= =========== ========== results_1mregr_c_ew_f 0 PRIMARY 1 id A 100000000 BTREE results_1mregr_c_ew_f 1 rc 1 rc A 2 BTREE results_1mregr_c_ew_f 1 rc 2 df A 223 BTREE 存储过程 我创建了一个简单的存储过程,该过程将获取所需的数据并对其进行处理(使用与示例相同的where条件) drop procedure if exists process_results_1mregr_c_ew_f; delimiter # create procedure process_results_1mregr_c_ew_f ( in p_rc tinyint unsigned, in p_df int unsigned ) begin declare v_count int unsigned default 0; declare v_done tinyint default 0; declare v_id int unsigned; declare v_result_cur cursor for select id from results_1mregr_c_ew_f where rc = p_rc and df > p_df; declare continue handler for not found set v_done = 1; open v_result_cur; repeat fetch v_result_cur into v_id; set v_count = v_count + 1; -- do work... until v_done end repeat; close v_result_cur; select v_count as counter; end # delimiter ; 观察到以下运行时: call process_results_1mregr_c_ew_f(0,60); runtime 1 = 03:24.999 Query OK (3 mins 25 secs) runtime 2 = 03:32.196 Query OK (3 mins 32 secs) call process_results_1mregr_c_ew_f(1,60); runtime 1 = 04:59.861 Query OK (4 mins 59 secs) runtime 2 = 04:41.814 Query OK (4 mins 41 secs) counter 23000002 (23 million rows processed in each case) 嗯,性能有些令人失望,因此进入下一个想法。 考虑使用innodb引擎(令人震惊的恐怖) 为什么是innodb?因为它具有聚簇索引!您会发现使用innodb的插入速度较慢,但​​希望读取速度会更快,因此这是值得的折衷选择。 通过聚集索引访问行的速度很快,因为行数据位于索引搜索所位于的同一页上。如果表很大,则与使用不同于索引记录的页面存储行数据的存储组织相比,聚集索引体系结构通常可以节省磁盘I / O操作。例如,MyISAM将一个文件用于数据行,将另一个文件用于索引记录。 更多信息在这里: http://dev.mysql.com/doc/refman/5.0/en/innodb-index-types.html 简化的innodb结果表 drop table if exists results_innodb; create table results_innodb ( rc tinyint unsigned not null, df int unsigned not null default 0, id int unsigned not null, -- cant auto_inc this !! val double(10,4) not null default 0, ts timestamp not null default now(), primary key (rc, df, id) -- note clustered (innodb only !) composite PK ) engine=innodb; innodb的一个问题是它不支持构成复合键一部分的auto_increment字段,因此您必须自己使用序列生成器,触发器或其他方法(可能是在填充结果表本身的应用程序中)提供递增的键值?? 同样,我生成了1亿行数据,这些键字段的基数与您的示例大致相同。如果这些数字与myisam示例不匹配,请不要担心,因为innodb估计基数,因此它们不会完全相同。(但它们-使用相同的数据集) show indexes from results_innodb; Table Non_unique Key_name Seq_in_index Column_name Collation Cardinality Index_type ===== ========== ======== ============ =========== ========= =========== ========== results_innodb 0 PRIMARY 1 rc A 18 BTREE results_innodb 0 PRIMARY 2 df A 18 BTREE results_innodb 0 PRIMARY 3 id A 100000294 BTREE 存储过程 存储过程与上面的myisam示例完全相同,但是从innodb表中选择数据。 declare v_result_cur cursor for select id from results_innodb where rc = p_rc and df > p_df; 结果如下: call process_results_innodb(0,60); runtime 1 = 01:53.407 Query OK (1 mins 53 secs) runtime 2 = 01:52.088 Query OK (1 mins 52 secs) call process_results_innodb(1,60); runtime 1 = 02:01.201 Query OK (2 mins 01 secs) runtime 2 = 01:49.737 Query OK (1 mins 50 secs) counter 23000002 (23 million rows processed in each case) 比myisam引擎实施快约2-3分钟!(innodb FTW) 分而治之 在使用游标的服务器端存储过程中处理结果可能不是最佳解决方案,尤其是因为MySQL不支持诸如数组和复杂数据结构之类的东西,而这些东西在3GL语言(如C#等)或什至在其他数据库(如作为Oracle PL / SQL。 因此,这里的想法是将成批的数据返回到应用程序层(C#等),然后可以将结果添加到基于集合的数据结构中,然后在内部处理数据。 存储过程 该存储过程需要3个参数rc,df_low和df_high,这使您可以选择以下数据范围: call list_results_innodb(0,1,1); -- df 1 call list_results_innodb(0,1,10); -- df between 1 and 10 call list_results_innodb(0,60,120); -- df between 60 and 120 etc... 显然,df范围越高,您将提取的数据越多。 drop procedure if exists list_results_innodb; delimiter # create procedure list_results_innodb ( in p_rc tinyint unsigned, in p_df_low int unsigned, in p_df_high int unsigned ) begin select rc, df, id from results_innodb where rc = p_rc and df between p_df_low and p_df_high; end # delimiter ; 我还敲出了一个myisam版本,除了所使用的表外,该版本完全相同。 call list_results_1mregr_c_ew_f(0,1,1); call list_results_1mregr_c_ew_f(0,1,10); call list_results_1mregr_c_ew_f(0,60,120); 基于上面的光标示例,我希望innodb版本的性能优于myisam版本。 我开发了一个快速且肮脏的多线程C#应用程序,该应用程序将调用存储过程并将结果添加到集合中以进行后查询处理。您不必使用线程,可以按顺序完成相同的批处理查询方法,而不会造成性能损失。 每个线程(QueryThread)选择一个df数据范围,循环结果集,并将每个结果(行)添加到结果集合中。 class Program { static void Main(string[] args) { const int MAX_THREADS = 12; const int MAX_RC = 120; List<AutoResetEvent> signals = new List<AutoResetEvent>(); ResultDictionary results = new ResultDictionary(); // thread safe collection DateTime startTime = DateTime.Now; int step = (int)Math.Ceiling((double)MAX_RC / MAX_THREADS) -1; int start = 1, end = 0; for (int i = 0; i < MAX_THREADS; i++){ end = (i == MAX_THREADS - 1) ? MAX_RC : end + step; signals.Add(new AutoResetEvent(false)); QueryThread st = new QueryThread(i,signals[i],results,0,start,end); start = end + 1; } WaitHandle.WaitAll(signals.ToArray()); TimeSpan runTime = DateTime.Now - startTime; Console.WriteLine("{0} results fetched and looped in {1} secs\nPress any key", results.Count, runTime.ToString()); Console.ReadKey(); } } 运行时观察如下: Thread 04 done - 31580517 Thread 06 done - 44313475 Thread 07 done - 45776055 Thread 03 done - 46292196 Thread 00 done - 47008566 Thread 10 done - 47910554 Thread 02 done - 48194632 Thread 09 done - 48201782 Thread 05 done - 48253744 Thread 08 done - 48332639 Thread 01 done - 48496235 Thread 11 done - 50000000 50000000 results fetched and looped in 00:00:55.5731786 secs Press any key 因此,在不到60秒的时间内获取了5000万行并将其添加到集合中。 我使用myisam存储过程尝试了同样的事情,该过程花了2分钟才能完成。 50000000 results fetched and looped in 00:01:59.2144880 secs 移至innodb 在我的简化系统中,myisam表的性能不会太差,因此可能不值得迁移到innodb。如果您确实决定将结果数据复制到innodb表中,请按照以下步骤进行操作: start transaction; insert into results_innodb select <fields...> from results_1mregr_c_ew_f order by ; commit; 在将整个事物插入并包装到事务中之前,通过innodb PK对结果进行排序将加快速度。 我希望其中一些证明是有帮助的。 祝好运

保持可爱mmm 2020-05-18 11:14:35 0 浏览量 回答数 0

阿里云高校特惠,助力学生创业梦!0元体验,快速入门云计算!

学生动手场景应用,快速了解并掌握云服务器的各种新奇玩法!

回答

1.中间件应该一种架构方法,不局限于特定的语言。 例如提供不同应用之间消息通讯的消息中间件。淘宝下面很多产品之间都需要信息共享,通过一个中间人来专门传递消息。这样做很容易扩展,对上层应用提供统一消息操作接口就行了。2.单个程序内部也可以有中间件,一个程序内部实现对中间件接口对支持。例如web程序,在统一的入口处,加上 middleware->call(),只要实现了call接口的中间件,就可以在程序实际执行前做很多自定义的动作,例如用户检查、日志记录。 class user_check_middleware() { public function call() { //do user check $app->next_middleware->call(); } } class log_middleware() { public function call(){ //do log $app->next_middleware->call(); } } 这样通过新增中间件,不去修改核心代码,就可以扩展系统。这种设计方法,解耦,伸缩性很好,应用很广泛。

蛮大人123 2019-12-02 01:55:27 0 浏览量 回答数 0

回答

键点就是OrderedMeta元类中定义的 __prepare__() 方法。 这个方法会在开始定义类和它的父类的时候被执行。它必须返回一个映射对象以便在类定义体中被使用到。 我们这里通过返回了一个OrderedDict而不是一个普通的字典,可以很容易的捕获定义的顺序。 如果你想构造自己的类字典对象,可以很容易的扩展这个功能。比如,下面的这个修改方案可以防止重复的定义: from collections import OrderedDict class NoDupOrderedDict(OrderedDict): def init(self, clsname): self.clsname = clsname super().init() def setitem(self, name, value): if name in self: raise TypeError('{} already defined in {}'.format(name, self.clsname)) super().setitem(name, value) class OrderedMeta(type): def new(cls, clsname, bases, clsdict): d = dict(clsdict) d['_order'] = [name for name in clsdict if name[0] != '_'] return type.new(cls, clsname, bases, d) @classmethod def __prepare__(cls, clsname, bases): return NoDupOrderedDict(clsname) 下面我们测试重复的定义会出现什么情况: class A(metaclass=OrderedMeta): ... def spam(self): ... pass ... def spam(self): ... pass ... Traceback (most recent call last): File " ", line 1, in File " ", line 4, in A File "dupmethod2.py", line 25, in setitem (name, self.clsname)) TypeError: spam already defined in A 最后还有一点很重要,就是在 new() 方法中对于元类中被修改字典的处理。 尽管类使用了另外一个字典来定义,在构造最终的 class 对象的时候, 我们仍然需要将这个字典转换为一个正确的 dict 实例。 通过语句 d = dict(clsdict) 来完成这个效果。 对于很多应用程序而已,能够捕获类定义的顺序是一个看似不起眼却又非常重要的特性。 例如,在对象关系映射中,我们通常会看到下面这种方式定义的类: class Stock(Model): name = String() shares = Integer() price = Float() 在框架底层,我们必须捕获定义的顺序来将对象映射到元组或数据库表中的行(就类似于上面例子中的 as_csv() 的功能)。 这节演示的技术非常简单,并且通常会比其他类似方法(通常都要在描述器类中维护一个隐藏的计数器)要简单的多。

景凌凯 2020-04-17 17:39:38 0 浏览量 回答数 0

问题

指示方向是传入还是传出

几许相思几点泪 2019-12-22 18:44:51 0 浏览量 回答数 0

问题

性能测试 PTS 脚本编写如何进行?

猫饭先生 2019-12-01 21:25:43 2320 浏览量 回答数 0

回答

为了显示点心栏,您必须引用您的应用程序已构建的特定支架实例,并告诉它显示点心栏。如果上下文方便,您可以说Scaffold.of(context).showSnackbar(快餐栏); 由于您无权访问上下文,因此引用支架的另一种方法是为支架定义一个键,然后确保将该键分配给Webviewer的支架。 你可以说 class MessageHandler extends StatefulWidget { // pass a reference to the scaffold key to the message handler when it is created final GlobalKey<ScaffoldState> scaffoldKey; MessageHandler({this.scaffoldKey}); @override _MessageHandlerState createState() => _MessageHandlerState(); } class _MessageHandlerState extends State<MessageHandler>{ final FirebaseMessaging _fcm = FirebaseMessaging(); @override void initState(){ super.initState(); _fcm.configure( onMessage: (Map<String, dynamic> message) async { print("here"); print("onMessage: $message"); final snackbar = SnackBar( content: Text(message['notification']['title']), ); // reference the scaffold with its key and call showSnackBar widget.scaffoldKey.currentState.showSnackbar(snackbar); }, ); 然后在可以传递给消息处理程序和支架的地方定义支架的密钥: final GlobalKey<ScaffoldState> scaffoldKey = new GlobalKey<ScaffoldState>(); .... Scaffold( key: scaffoldKey, ... 更多信息: 在Flutter中显示SnackBar

LiuWH 2020-01-18 10:41:09 0 浏览量 回答数 0

问题

android tabhost 跨点击出错. 400 请求出错 

kun坤 2020-05-25 20:34:55 11 浏览量 回答数 1

问题

android tabhost 跨点击出错(代码已贴出)?报错

爱吃鱼的程序员 2020-06-22 14:48:08 0 浏览量 回答数 1

回答

"难道没有人用过吗?应该是很常见的应用吧###### 既然是分页你何必又要再用存储过程封装呢?直接在xml写sql把这样好扩展。  <select id="querySearchReverseList" statementType="CALLABLE" >         {call SP_OD_SEARCHREVERSE_BEGIN(#{pageNo},#{pageSize},#{status},#{result,mode=OUT,javaType=java.sql.ResultSet,jdbcType=CURSOR,resultMap=OrderInfoVo.querySearchReverseResult})}      </select> 原来我也用过,而且返回的是一个resultset 但是效率不行。特别是平凡查询的时候###### CREATE OR REPLACE PROCEDURE SP_OD_SEARCHREVERSE_BEGIN(v_pageNo number, --查询页码 v_pageSize number, --每页显示大小 v_status in VARCHAR2, --要获取的状态 v_resultCur out HF_CURSOR.CURSOR_TYPE) --获取记录集合 is /************************************************************ ************************************************************/ l_pageNo number(10); l_pageSize number(10); BEGIN if v_pageSize is null or v_pageSize = 0 then l_pageSize := 10; else l_pageSize := v_pageSize; end if; OPEN v_resultCur FOR select xxxx, xxxx, xxxx, xxxx, xxxx from (select r.xxx, f.xxx, f.xxx, f.xxx, f.xxx from OD_1 r, OD_2 f, OD_3 o, CH_4 c where r.xxx = f.xxx order by r.xxxx asc ) where rownum <= l_pageSize; --close v_resultCur; -- 不能关闭 END;       create or replace package HF_CURSOR is -- Author : ADMINISTRATOR -- Created : 2011-5-23 10:03:47 -- Purpose : FOR RETURN LIST -- Public type declarations TYPE CURSOR_TYPE IS REF CURSOR; --定义游标 end HF_CURSOR; ######感谢你的回复,我已经解决了,和你的方法差不多" ![image.png](https://ucc.alicdn.com/pic/developer-ecology/d8b6bbdac42548c9a786e2635e500e2d.png)

montos 2020-05-30 10:44:58 0 浏览量 回答数 0

问题

深入理解 Redis 主键失效原理及实现机制:报错

kun坤 2020-06-07 14:14:55 0 浏览量 回答数 1

回答

生成器也是一种迭代器,但是你只能对其迭代一次。这是因为它们并没有把所有的值存在内存中,而是在运行时生成值。你通过遍历来使用它们,要么用一个“for”循环,要么将它们传递给任意可以进行迭代的函数和结构。大多数时候生成器是以函数来实现的。然而,它们并不返回一个值,而是yield(暂且译作“生出”)一个值。这里有个生成器函数的简单例子: def generator_function(): for i in range(10): yield i for item in generator_function(): print(item) # Output: 0 # 1 # 2 # 3 # 4 # 5 # 6 # 7 # 8 # 9 这个案例并不是非常实用。生成器最佳应用场景是:你不想同一时间将所有计算出来的大量结果集分配到内存当中,特别是结果集里还包含循环。 译者注:这样做会消耗大量资源 许多Python 2里的标准库函数都会返回列表,而Python 3都修改成了返回生成器,因为生成器占用更少的资源。 下面是一个计算斐波那契数列的生成器: # generator version def fibon(n): a = b = 1 for i in range(n): yield a a, b = b, a + b 函数使用方法如下: for x in fibon(1000000): print(x) 用这种方式,我们可以不用担心它会使用大量资源。然而,之前如果我们这样来实现的话: def fibon(n): a = b = 1 result = [] for i in range(n): result.append(a) a, b = b, a + b return result 这也许会在计算很大的输入参数时,用尽所有的资源。我们已经讨论过生成器使用一次迭代,但我们并没有测试过。在测试前你需要再知道一个Python内置函数:next()。它允许我们获取一个序列的下一个元素。那我们来验证下我们的理解: def generator_function(): for i in range(3): yield i gen = generator_function() print(next(gen)) # Output: 0 print(next(gen)) # Output: 1 print(next(gen)) # Output: 2 print(next(gen)) # Output: Traceback (most recent call last): # File "<stdin>", line 1, in <module> # StopIteration 我们可以看到,在yield掉所有的值后,next()触发了一个StopIteration的异常。基本上这个异常告诉我们,所有的值都已经被yield完了。你也许会奇怪,为什么我们在使用for循环时没有这个异常呢?啊哈,答案很简单。for循环会自动捕捉到这个异常并停止调用next()。你知不知道Python中一些内置数据类型也支持迭代哦?我们这就去看看: my_string = "Yasoob" next(my_string) # Output: Traceback (most recent call last): # File "<stdin>", line 1, in <module> # TypeError: str object is not an iterator 好吧,这不是我们预期的。这个异常说那个str对象不是一个迭代器。对,就是这样!它是一个可迭代对象,而不是一个迭代器。这意味着它支持迭代,但我们不能直接对其进行迭代操作。那我们怎样才能对它实施迭代呢?是时候学习下另一个内置函数,iter。它将根据一个可迭代对象返回一个迭代器对象。这里是我们如何使用它: my_string = "Yasoob" my_iter = iter(my_string) next(my_iter) # Output: 'Y' 现在好多啦。我肯定你已经爱上了学习生成器。一定要记住,想要完全掌握这个概念,你只有使用它。确保你按照这个模式,并在生成器对你有意义的任何时候都使用它。你绝对不会失望的!

montos 2020-04-16 17:47:35 0 浏览量 回答数 0

回答

难道没有人用过吗?应该是很常见的应用吧###### 既然是分页你何必又要再用存储过程封装呢?直接在xml写sql把这样好扩展。  <select id="querySearchReverseList" statementType="CALLABLE" >         {call SP_OD_SEARCHREVERSE_BEGIN(#{pageNo},#{pageSize},#{status},#{result,mode=OUT,javaType=java.sql.ResultSet,jdbcType=CURSOR,resultMap=OrderInfoVo.querySearchReverseResult})}      </select> 原来我也用过,而且返回的是一个resultset 但是效率不行。特别是平凡查询的时候###### CREATE OR REPLACE PROCEDURE SP_OD_SEARCHREVERSE_BEGIN(v_pageNo number, --查询页码 v_pageSize number, --每页显示大小 v_status in VARCHAR2, --要获取的状态 v_resultCur out HF_CURSOR.CURSOR_TYPE) --获取记录集合 is /************************************************************ ************************************************************/ l_pageNo number(10); l_pageSize number(10); BEGIN if v_pageSize is null or v_pageSize = 0 then l_pageSize := 10; else l_pageSize := v_pageSize; end if; OPEN v_resultCur FOR select xxxx, xxxx, xxxx, xxxx, xxxx from (select r.xxx, f.xxx, f.xxx, f.xxx, f.xxx from OD_1 r, OD_2 f, OD_3 o, CH_4 c where r.xxx = f.xxx order by r.xxxx asc ) where rownum <= l_pageSize; --close v_resultCur; -- 不能关闭 END;       create or replace package HF_CURSOR is -- Author : ADMINISTRATOR -- Created : 2011-5-23 10:03:47 -- Purpose : FOR RETURN LIST -- Public type declarations TYPE CURSOR_TYPE IS REF CURSOR; --定义游标 end HF_CURSOR; ######感谢你的回复,我已经解决了,和你的方法差不多

kun坤 2020-06-06 17:41:23 0 浏览量 回答数 0

回答

您可以在一个EMR上顺序运行多个spark作业 - 也就是说,下一个作业将在上一个作业完成后启动。这是使用EMR步骤完成的。 我使用Java SDK来运行它,但您可以在本文档中看到如何仅使用CLI添加步骤。 我下面的代码使用spark-submit,但它不会像在CLI中运行那样直接运行。相反,我将其作为shell脚本运行,并包含HADOOP_USER_NAME的环境变量,因此spark作业在我指定的用户名下运行。如果要在登录到EMR的用户名(默认为hadoop)下运行作业,可以跳过它。 在下面的代码摘录中,对象emr是类型AmazonElasticMapReduce,在sdk中提供。如果您使用CLI方法,则不需要它。 一些辅助方法是uploadConfFile不言自明的。我用了一个广泛的配置为spark应用程序,不同的是files和jars其可以是本地或S3 / HDFS,配置文件必须在EMR本身的本地文件。 完成后,您将在EMR集群上创建一个步骤,该步骤将启动新的spark应用程序。您可以在EMR上指定许多步骤,这些步骤将一个接一个地运行。 //Upload the spark configuration you wish to use to a local file uploadConfFile(clusterId, sparkConf, confFileName); //create a list of arguments - which is the complete command for spark-submitList stepargs = new ArrayList();//start with an envelope to specify the hadoop user namestepargs.add("/bin/sh");stepargs.add("-c");//call to spark-submit with the incantation stating its arguments are provided next.stepargs.add("HADOOP_USER_NAME="+task.getUserName()+" spark-submit "$@"");stepargs.add("sh");//add the spark-submit argumentsstepargs.add("--class");stepargs.add(mainClass);stepargs.add("--deploy-mode");stepargs.add("cluster");stepargs.add("--master");stepargs.add("yarn");stepargs.add("--files");//a comma-separated list of file paths in s3stepargs.add(files);stepargs.add("--jars");//a comma-separated list of file paths in s3stepargs.add(jars);stepargs.add("--properties-file");//the file we uploaded to the EMR, with its full pathstepargs.add(confFileName);stepargs.add(jar);//add the jar specific arguments in here AddJobFlowStepsResult result = emr.addJobFlowSteps(new AddJobFlowStepsRequest() .withJobFlowId(clusterId) .withSteps(new StepConfig() .withName(name) .withActionOnFailure(ActionOnFailure.CONTINUE) .withHadoopJarStep(new HadoopJarStepConfig() .withJar("command-runner.jar") .withArgs(stepargs))));

小六码奴 2019-12-02 02:02:03 0 浏览量 回答数 0

回答

使用swift新建一个ios工程,工程里面主要创建了几个文件,其实这几个文件在之前学OC的时候也简单知道了一些,但是在这里要系统的学习Swift了,所以还是要仔细再看看。 AppDelegate.swift // 导入iOS中所有控件的库文件UIKit import UIKit // 调用了OC中的UIApplicationMain函数,它是iOS应用程序的入口,它会创建了一个UIApplication对象, // 代表当前应用程序.作用是用来检测当前应用程序状态的改变,还会创建一个遵守UIApplicationDelegate的协议的子类对象作为UIApplication的代理, // 作用是处理应用程序状态的改变(创建AppDelegate对象并且设置为UIApplication对象的代理) @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { // 类似Android中的PhoneWindow窗口 var window: UIWindow? // 应用程序启动成功后,会自动调用到该方法 func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { // Override point for customization after application launch. // 在这个方法中搭建应用程序界面、获取数据然后再展现,如果不在该方法中创建window, //那么程序会通过Main.storyboard去创建应用程序界面 return true } // 将要变成非活跃状态时的回调(不可见),理解成Android中activity的生命周期 func applicationWillResignActive(_ application: UIApplication) { // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state. // Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game. } // 后台时调用 func applicationDidEnterBackground(_ application: UIApplication) { // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits. } // 进入前台时 func applicationWillEnterForeground(_ application: UIApplication) { // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background. } // 变成活跃状态 func applicationDidBecomeActive(_ application: UIApplication) { // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface. } // 应用程序将要终止 func applicationWillTerminate(_ application: UIApplication) { // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:. } } ViewController.swift import UIKit class ViewController: UIViewController { // 程序加载完成后的逻辑处理 override func viewDidLoad() { super.viewDidLoad() // Do any additional setup after loading the view, typically from a nib. } } Main.storyboard 类似Android中的xml文件等,可以写布局 Assets.xcassets 放图片等资源 LaunchScreen.storyboard 启动页面

刘刚_ 2020-05-15 16:12:06 0 浏览量 回答数 0

问题

支付宝开放平台消息服务的WebSocket方式接入时,如果接口加签方式设置公钥证书时应该怎么接入

游客fppasy53lzeg4 2019-12-01 21:49:17 45 浏览量 回答数 0

问题

深入理解Magento – 第六章 – 高级Magento模型 :报错

kun坤 2020-06-14 15:19:25 0 浏览量 回答数 1

问题

深入理解Magento – 第六章 – 高级Magento模型:配置报错 

kun坤 2020-06-02 14:47:07 2 浏览量 回答数 1

问题

深入理解Magento – 第六章 – 高级Magento模型 - Magento报错

montos 2020-06-03 20:30:01 2 浏览量 回答数 1

问题

路由与视图 400 请求报错 

kun坤 2020-05-30 15:21:09 0 浏览量 回答数 1

问题

Java SDK是什么?

nicenelly 2019-12-01 21:28:02 1867 浏览量 回答数 0

回答

如何做Python复制文件 - 9种学习方式。以下是演示“如何在Python中复制文件”的九种方法。shutil copyfile()方法shutil copy()方法shutil copyfileobj()方法shutil copy2()方法os popen方法os系统()方法Thread()方法子进程调用()方法子进程check_output()方法Shutil Copyfile()方法该方法只有在目标可写时才将源的内容复制到目的地。如果您没有写入权限,则会引发IOError。它通过打开输入文件进行阅读,忽略其文件类型。接下来,它不会对特殊文件进行任何不同的处理,也不会将它们复制为新的特殊文件。所述的CopyFile()方法利用较低级别的功能的copyfileobj()的下方。它将文件名称作为参数,打开它们并将文件句柄传递给copyfileobj()。该方法中有一个可选的第三个参数,您可以使用它来指定缓冲区长度。然后它将打开文件以读取指定缓冲区大小的块。但是,默认行为是一次性读取整个文件。以下是有关copyfile()方法的要点。它将源的内容复制到名为目标的文件。如果目的地不可写,则复制操作将导致IOError异常。如果源文件和目标文件都相同,它将返回SameFileError。但是,如果目的地以不同的名称预先存在,则副本将覆盖其内容。如果目的地是目录,则意味着此方法将不会复制到目录,将会发生错误13。它不支持复制文件,如字符或块设备和管道。Shutil Copy()方法copy()方法的功能类似于“CP”在Unix命令。这意味着如果目标是一个文件夹,那么它将在其中创建一个与源文件相同的名称(basename)的新文件。此外,该方法将复制其内容后将目标文件的权限与源进行同步。 如果要复制相同的文件,它也会抛出SameFileError。Shutil Copyfileobj()方法此方法将文件复制到目标路径或文件对象。如果目标是文件对象,则需要在调用copyfileobj()之后明确关闭它。它假设一个可选参数(缓冲区大小),您可以使用它来提供缓冲区长度。这是在复制过程中保存在内存中的字节数。系统使用的默认大小为16KB。Shutil Copy2()方法但是,copy2()方法的功能类似于copy()。但是,在复制数据的同时,也可以在元数据中添加访问和修改时间。复制同一个文件会导致SameFileError。对于好奇 - Copymode()与Copystat()之间的区别。Os Popen()方法该方法创建一个指向或来自该命令的管道。它返回一个连接到管道的打开的文件对象。您可以根据文件打开模式(即'r'(默认)或'w')使用它进行读取或写入。模式 -它可以是'r'(默认)或'w'。bufsize -如果其值为0,则不会发生缓冲。如果设置为1,则在访问文件时将进行行缓冲。如果您提供的值大于1,则缓冲将以指定的缓冲区大小进行。但是,对于负值,系统将采用默认缓冲区大小。对于Windows操作系统。对于Linux操作系统。Os System()方法它是运行任何系统命令的最常见方式。使用system()方法,可以在subshell中调用任何命令。在内部,这种方法会调用标准的C库函数。此方法返回命令的退出状态。7.以Async方式使用线程库的Python文件复制如果要以异步方式复制文件,请使用以下方法。在这里,我们使用Python的线程模块在后台运行复制操作。使用此方法时,请确保采用锁定以避免死锁。如果您的应用程序正在使用多个线程读取/写入文件,您可能会面对它。8.使用子进程的Call()方法在Python中复制一个文件子进程模块提供了一个简单的界面来处理子进程。它使我们能够启动子进程,附加到其输入/输出/错误管道,并检索返回值。子流程模块旨在替代传统模块和功能,如os.system,os.spawn ,os.popen ,popen2。*。它公开一个call()方法来调用系统命令来执行用户任务。9.使用子进程的Check_output()方法在Python中复制文件使用子进程的check_output()方法,可以运行外部命令或程序并捕获其输出。它还支持管道。来源:网络

51干警网 2019-12-02 01:10:47 0 浏览量 回答数 0

问题

Android小项目之--电话与短信服务(附源码)? 400 报错

优选2 2020-06-05 16:49:01 0 浏览量 回答数 1

问题

Android小项目之--电话与短信服务(附源码)? 400 报错

爱吃鱼的程序员 2020-05-29 20:02:00 0 浏览量 回答数 1

回答

触及 multiple inheritance (MI)(多继承)的时候,C++ 社区就会鲜明地分裂为两个基本的阵营。一个阵营认为如果 single inheritance (SI)(单继承)是有好处的,multiple inheritance(多继承)一定更有好处。另一个阵营认为 single inheritance(单继承)有好处,但是多继承引起的麻烦使它得不偿失。在本文中,我们的主要目的是理解在 MI 问题上的这两种看法。   首要的事情之一是要承认当将 MI 引入设计领域时,就有可能从多于一个的 base class(基类)中继承相同的名字(例如,函数,typedef,等等)。这就为歧义性提供了新的时机。例如: class BorrowableItem { // something a library lets you borrowpublic: void checkOut(); // check the item out from the library ..}; class ElectronicGadget {private: bool checkOut() const; // perform self-test, return whether ... // test succeeds}; class MP3Player: // note MI herepublic BorrowableItem, // (some libraries loan MP3 players)public ElectronicGadget{ ... }; // class definition is unimportant MP3Player mp; mp.checkOut(); // ambiguous! which checkOut?    注意这个例子,即使两个函数中只有一个是可访问的,对 checkOut 的调用也是有歧义的。(checkOut 在 BorrowableItem 中是 public(公有)的,但在 ElectronicGadget 中是 private(私有)的。)这与 C++ 解析 overloaded functions(重载函数)调用的规则是一致的:在看到一个函数的是否可访问之前,C++ 首先确定与调用匹配最好的那个函数。只有在确定了 best-match function(最佳匹配函数)之后,才检查可访问性。这目前的情况下,两个 checkOuts 具有相同的匹配程度,所以就不存在最佳匹配。因此永远也不会检查到 ElectronicGadget::checkOut 的可访问性。   为了消除歧义性,你必须指定哪一个 base class(基类)的函数被调用: mp.BorrowableItem::checkOut(); // ah, that checkOut...   当然,你也可以尝试显式调用 ElectronicGadget::checkOut,但这样做会有一个 "you're trying to call a private member function"(你试图调用一个私有成员函数)错误代替歧义性错误。    multiple inheritance(多继承)仅仅意味着从多于一个的 base class(基类)继承,但是在还有 higher-level base classes(更高层次基类)的 hierarchies(继承体系)中出现 MI 也并不罕见。这会导致有时被称为 "deadly MI diamond"(致命的多继承菱形)的后果。 class File { ... };class InputFile: public File { ... };class OutputFile: public File { ... };class IOFile: public InputFile,public OutputFile{ ... };    在一个“在一个 base class(基类)和一个 derived class(派生类)之间有多于一条路径的 inheritance hierarchy(继承体系)”(就像上面在 File 和 IOFile 之间,有通过 InputFile 和 OutputFile 的两条路径)的任何时候,你都必须面对是否需要为每一条路径复制 base class(基类)中的 data members(数据成员)的问题。例如,假设 File class 有一个 data members(数据成员)fileName。IOFile 中应该有这个 field(字段)的多少个拷贝呢?一方面,它从它的每一个 base classes(基类)继承一个拷贝,这就暗示 IOFile 应该有两个 fileName data members(数据成员)。另一方面,简单的逻辑告诉我们一个 IOFile object(对象)应该仅有一个 file name(文件名),所以通过它的两个 base classes(基类)继承来的 fileName field(字段)不应该被复制。   C++ 在这个争议上没有自己的立场。它恰当地支持两种选项,虽然它的缺省方式是执行复制。如果那不是你想要的,你必须让这个 class(类)带有一个 virtual base class(虚拟基类)的数据(也就是 File)。为了做到这一点,你要让从它直接继承的所有的 classes(类)使用 virtual inheritance(虚拟继承): class File { ... };class InputFile: virtual public File { ... };class OutputFile: virtual public File { ... };class IOFile: public InputFile,public OutputFile{ ... };    标准 C++ 库包含一个和此类似的 MI hierarchy(继承体系),只是那个 classes(类)是 class templates(类模板),名字是 basic_ios,basic_istream,basic_ostream 和 basic_iostream,而不是 File,InputFile,OutputFile 和 IOFile。   从正确行为的观点 看,public inheritance(公有继承)应该总是 virtual(虚拟)的。如果这是唯一的观点,规则就变得简单了:你使用 public inheritance(公有继承)的任何时候,都使用 virtual public inheritance(虚拟公有继承)。唉,正确性不是唯一的视角。避免 inherited fields(继承来的字段)复制需要在编译器的一部分做一些 behind-the-scenes legerdemain(幕后的戏法),而结果是从使用 virtual inheritance(虚拟继承)的 classes(类)创建的 objects(对象)通常比不使用 virtual inheritance(虚拟继承)的要大。访问 virtual base classes(虚拟基类)中的 data members(数据成员)也比那些 non-virtual base classes(非虚拟基类)中的要慢。编译器与编译器之间有一些细节不同,但基本的要点很清楚:virtual inheritance costs(虚拟继承要付出成本)。   它也有一些其它方面的成本。支配 initialization of virtual base classes(虚拟基类初始化)的规则比 non-virtual bases(非虚拟基类)的更加复杂而且更不直观。初始化一个 virtual base(虚拟基)的职责由 hierarchy(继承体系)中 most derived class(层次最低的派生类)承担。这个规则中包括的含义:   (1) 从需要 initialization(初始化)的 virtual bases(虚拟基)派生的 classes(类)必须知道它们的 virtual bases(虚拟基),无论它距离那个 bases(基)有多远;   (2) 当一个新的 derived class(派生类)被加入继承体系时,它必须为它的 virtual bases(虚拟基)(包括直接的和间接的)承担 initialization responsibilities(初始化职责)。    我对于 virtual base classes(虚拟基类)(也就是 virtual inheritance(虚拟继承))的建议很简单。首先,除非必需,否则不要使用 virtual bases(虚拟基)。缺省情况下,使用 non-virtual inheritance(非虚拟继承)。第二,如果你必须使用 virtual base classes(虚拟基类),试着避免在其中放置数据。这样你就不必在意它的 initialization(初始化)(以及它的 turns out(清空),assignment(赋值))规则中的一些怪癖。值得一提的是 Java 和 .NET 中的 Interfaces(接口)不允许包含任何数据,它们在很多方面可以和 C++ 中的 virtual base classes(虚拟基类)相比照。   现在我们使用下面的 C++ Interface class(接口类)(参见《C++箴言:最小化文件之间的编译依赖》)来为 persons(人)建模: class IPerson {public: virtual ~IPerson();  virtual std::string name() const = 0; virtual std::string birthDate() const = 0;};    IPerson 的客户只能使用 IPerson 的 pointers(指针)和 references(引用)进行编程,因为 abstract classes(抽象类)不能被实例化。为了创建能被当作 IPerson objects(对象)使用的 objects(对象),IPerson 的客户使用 factory functions(工厂函数)(再次参见 Item 31)instantiate(实例化)从 IPerson 派生的 concrete classes(具体类): // factory function to create a Person object from a unique database ID;// see Item 18 for why the return type isn't a raw pointerstd::tr1::shared_ptr makePerson(DatabaseID personIdentifier); // function to get a database ID from the userDatabaseID askUserForDatabaseID(); DatabaseID id(askUserForDatabaseID());std::tr1::shared_ptr pp(makePerson(id)); // create an object// supporting the// IPerson interface ... // manipulate *pp via// IPerson's member// functions   但是 makePerson 怎样创建它返回的 pointers(指针)所指向的 objects(对象)呢?显然,必须有一些 makePerson 可以实例化的从 IPerson 派生的 concrete class(具体类)。    假设这个 class(类)叫做 CPerson。作为一个 concrete class(具体类),CPerson 必须提供它从 IPerson 继承来的 pure virtual functions(纯虚拟函数)的 implementations(实现)。它可以从头开始写,但利用包含大多数或全部必需品的现有组件更好一些。例如,假设一个老式的 database-specific class(老式的数据库专用类)PersonInfo 提供了 CPerson 所需要的基本要素: class PersonInfo {public: explicit PersonInfo(DatabaseID pid); virtual ~PersonInfo();  virtual const char * theName() const; virtual const char * theBirthDate() const; ... private: virtual const char * valueDelimOpen() const; // see virtual const char * valueDelimClose() const; // below ...};    你可以看出这是一个老式的 class(类),因为 member functions(成员函数)返回 const char*s 而不是 string objects(对象)。尽管如此,如果鞋子合适,为什么不穿呢?这个 class(类)的 member functions(成员函数)的名字暗示结果很可能会非常合适。   你突然发现 PersonInfo 是设计用来帮助以不同的格式打印 database fields(数据库字段)的,每一个字段的值的开始和结尾通过指定的字符串定界。缺省情况下,字段值开始和结尾定界符是方括号,所以字段值 "Ring-tailed Lemur" 很可能被安排成这种格式: [Ring-tailed Lemur]   根据方括号并非满足 PersonInfo 的全体客户的期望的事实,virtual functions(虚拟函数)valueDelimOpen 和 valueDelimClose 允许 derived classes(派生类)指定它们自己的开始和结尾定界字符串。PersonInfo 的 member functions(成员函数)的 implementations(实现)调用这些 virtual functions(虚拟函数)在它们返回的值上加上适当的定界符。作为一个例子使用 PersonInfo::theName,代码如下: const char * PersonInfo::valueDelimOpen() const{ return "["; // default opening delimiter} const char * PersonInfo::valueDelimClose() const{ return "]"; // default closing delimiter} const char * PersonInfo::theName() const{ // reserve buffer for return value; because this is // static, it's automatically initialized to all zeros static char value[Max_Formatted_Field_Value_Length];  // write opening delimiter std::strcpy(value, valueDelimOpen());  append to the string in value this object's name field (being careful to avoid buffer overruns!)  // write closing delimiter std::strcat(value, valueDelimClose());  return value;}    有人可能会质疑 PersonInfo::theName 的陈旧的设计(特别是一个 fixed-size static buffer(固定大小静态缓冲区)的使用,这样的东西发生 overrun(越界)和 threading(线程)问题是比较普遍的——参见《C++箴言:必须返回对象时别返回引用》),但是请把这样的问题放到一边而注意这里:theName 调用 valueDelimOpen 生成它要返回的 string(字符串)的开始定界符,然后它生成名字值本身,然后它调用 valueDelimClose。   因为 valueDelimOpen 和 valueDelimClose 是 virtual functions(虚拟函数),theName 返回的结果不仅依赖于 PersonInfo,也依赖于从 PersonInfo 派生的 classes(类)。    对于 CPerson 的实现者,这是好消息,因为当细读 IPerson documentation(文档)中的 fine print(晦涩的条文)时,你发现 name 和 birthDate 需要返回未经修饰的值,也就是,不允许有定界符。换句话说,如果一个人的名字叫 Homer,对那个人的 name 函数的一次调用应该返回 "Homer",而不是 "[Homer]"。   CPerson 和 PersonInfo 之间的关系是 PersonInfo 碰巧有一些函数使得 CPerson 更容易实现。这就是全部。因而它们的关系就是 is-implemented-in-terms-of,而我们知道有两种方法可以表现这一点:经由 composition(复合)(参见《C++箴言:通过composition模拟“has-a”》)和经由 private inheritance(私有继承)(参见《C++箴言:谨慎使用私有继承》)。《C++箴言:谨慎使用私有继承》 指出 composition(复合)是通常的首选方法,但如果 virtual functions(虚拟函数)要被重定义,inheritance(继承)就是必不可少的。在当前情况下,CPerson 需要重定义 valueDelimOpen 和 valueDelimClose,所以简单的 composition(复合)做不到。最直截了当的解决方案是让 CPerson 从 PersonInfo privately inherit(私有继承),虽然 《C++箴言:谨慎使用私有继承》 说过只要多做一点工作,则 CPerson 也能用 composition(复合)和 inheritance(继承)的组合有效地重定义 PersonInfo 的 virtuals(虚拟函数)。这里,我们用 private inheritance(私有继承)。   但 是 CPerson 还必须实现 IPerson interface(接口),而这被称为 public inheritance(公有继承)。这就引出一个 multiple inheritance(多继承)的合理应用:组合 public inheritance of an interface(一个接口的公有继承)和 private inheritance of an implementation(一个实现的私有继承): class IPerson { // this class specifies thepublic: // interface to be implemented virtual ~IPerson();  virtual std::string name() const = 0; virtual std::string birthDate() const = 0;}; class DatabaseID { ... }; // used below; details are// unimportant class PersonInfo { // this class has functionspublic: // useful in implementing explicit PersonInfo(DatabaseID pid); // the IPerson interface virtual ~PersonInfo();  virtual const char * theName() const; virtual const char * theBirthDate() const;  virtual const char * valueDelimOpen() const; virtual const char * valueDelimClose() const; ...}; class CPerson: public IPerson, private PersonInfo { // note use of MIpublic: explicit CPerson( DatabaseID pid): PersonInfo(pid) {} virtual std::string name() const // implementations { return PersonInfo::theName(); } // of the required // IPerson member virtual std::string birthDate() const // functions { return PersonInfo::theBirthDate(); }private: // redefinitions of const char * valueDelimOpen() const { return ""; } // inherited virtual const char * valueDelimClose() const { return ""; } // delimiter}; // functions   在 UML 中,这个设计看起来像这样:   这个例子证明 MI 既是有用的,也是可理解的。    时至今日,multiple inheritance(多继承)不过是 object-oriented toolbox(面向对象工具箱)里的又一种工具而已,典型情况下,它的使用和理解更加复杂,所以如果你得到一个或多或少等同于一个 MI 设计的 SI 设计,则 SI 设计总是更加可取。如果你能拿出来的仅有的设计包含 MI,你应该更加用心地考虑一下——总会有一些方法使得 SI 也能做到。但同时,MI 有时是最清晰的,最易于维护的,最合理的完成工作的方法。在这种情况下,毫不畏惧地使用它。只是要确保谨慎地使用它。   Things to Remember   ·multiple inheritance(多继承)比 single inheritance(单继承)更复杂。它能导致新的歧义问题和对 virtual inheritance(虚拟继承)的需要。    ·virtual inheritance(虚拟继承)增加了 size(大小)和 speed(速度)成本,以及 initialization(初始化)和 assignment(赋值)的复杂度。当 virtual base classes(虚拟基类)没有数据时它是最适用的。   ·multiple inheritance(多继承)有合理的用途。一种方案涉及组合从一个 Interface class(接口类)的 public inheritance(公有继承)和从一个有助于实现的 class(类)的 private inheritance(私有继承)。 关于虚拟继承的思考虚拟继承在一般的应用中很少用到,所以也往往被忽视,这也主要是因为在C++中,多重继承是不推荐的,而一旦离开了多重继承,虚拟继承就完全失去了存在的必要(因为这样只会降低效率和占用更多的空间,实在是一无是处)。  以下面的一个例子为例:  #include   #include   class CA  {   int k; //为了便于说明后面的内存结构特别添加  public:   void f() {cout << "CA::f" << endl;}  };  class CB : public CA  {  };  class CC : public CA  {  };  class CD : public CB, public CC  {  };  void main()  {   CD d;   d.f();  }  当编译上述代码时,我们会收到如下的错误提示:  error C2385: 'CD::f' is ambiguous  即编译器无法确定你在d.f()中要调用的函数f到底是哪一个。这里可能会让人觉得有些奇怪,命名只定义了一个CA::f,既然大家都派生自CA,那自然就是调用的CA::f,为什么还无法确定呢?  这是因为编译器在进行编译的时候,需要确定子类的函数定义,如CA::f是确定的,那么在编译CB、CC时还需要在编译器的语法树中生成CB::f,CC::f等标识,那么,在编译CD的时候,由于CB、CC都有一个函数f,此时,编译器将试图生成两个CD::f标识,显然这时就要报错了。(当我们不使用CD::f的时候,以上标识都不会生成,所以,如果去掉d.f()一句,程序将顺利通过编译)  要解决这个问题,有两个方法:  1、重载函数f():此时由于我们明确定义了CD::f,编译器检查到CD::f()调用时就无需再像上面一样去逐级生成CD::f标识了;  此时CD的元素结构如下:  --------  |CB(CA)|  |CC(CA)|  --------  故此时的sizeof(CD) = 8;(CB、CC各有一个元素k)  2、使用虚拟继承:虚拟继承又称作共享继承,这种共享其实也是编译期间实现的,当使用虚拟继承时,上面的程序将变成下面的形式:  #include   #include   class CA  {   int k;  public:   void f() {cout << "CA::f" << endl;}  };  class CB : virtual public CA  {  };  class CC : virtual public CA  {  };  class CD : public CB, public CC  {  };  void main()  {   CD d;   d.f();  }  此时,当编译器确定d.f()调用的具体含义时,将生成如下的CD结构:  ----  |CB|  |CC|  |CA|  ----  同时,在CB、CC中都分别包含了一个指向CA的vbptr(virtual base table pointer),其中记录的是从CB、CC的元素到CA的元素之间的偏移量。此时,不会生成各子类的函数f标识,除非子类重载了该函数,从而达到“共享”的目的。  也正因此,此时的sizeof(CD) = 12(两个vbptr + sizoef(int));

a123456678 2019-12-02 01:58:07 0 浏览量 回答数 0

回答

1 写出下面代码输出内容。 package main import (    "fmt" ) funcmain() {     defer_call() } funcdefer_call() {     deferfunc() {fmt.Println("打印前")}()     deferfunc() {fmt.Println("打印中")}()     deferfunc() {fmt.Println("打印后")}()     panic("触发异常") } 考点:defer执行顺序 解答: defer 是后进先出。 panic 需要等defer 结束后才会向上传递。 出现panic恐慌时候,会先按照defer的后入先出的顺序执行,最后才会执行panic。 打印后 打印中 打印前 panic: 触发异常 2 以下代码有什么问题,说明原因。 type student struct {     Name string     Age  int } funcpase_student() {     m := make(map[string]*student)     stus := []student{         {Name: "zhou",Age: 24},         {Name: "li",Age: 23},         {Name: "wang",Age: 22},     }    for _,stu := range stus {         m[stu.Name] =&stu     } } 考点:foreach 解答: 这样的写法初学者经常会遇到的,很危险! 与Java的foreach一样,都是使用副本的方式。所以m[stu.Name]=&stu实际上一致指向同一个指针, 最终该指针的值为遍历的最后一个struct的值拷贝。 就像想修改切片元素的属性: for _, stu := rangestus {     stu.Age = stu.Age+10} 也是不可行的。 大家可以试试打印出来: func pase_student() {     m := make(map[string]*student)     stus := []student{         {Name: "zhou",Age: 24},         {Name: "li",Age: 23},         {Name: "wang",Age: 22},     }         // 错误写法     for _,stu := range stus {         m[stu.Name] =&stu     }          fork,v:=range m{               println(k,"=>",v.Name)     }           // 正确     for i:=0;i<len(stus);i++ {        m[stus[i].Name] = &stus[i]     }          fork,v:=range m{                println(k,"=>",v.Name)     } } 3 下面的代码会输出什么,并说明原因 func main() {     runtime.GOMAXPROCS(1)     wg := sync.WaitGroup{}     wg.Add(20)   for i := 0; i < 10; i++ {                  gofunc() {            fmt.Println("A: ", i)            wg.Done()         }()     }             for i:= 0; i < 10; i++ {                    gofunc(i int) {            fmt.Println("B: ", i)            wg.Done()         }(i)     }     wg.Wait() } 考点:go执行的随机性和闭包 解答: 谁也不知道执行后打印的顺序是什么样的,所以只能说是随机数字。 但是A:均为输出10,B:从0~9输出(顺序不定)。 第一个go func中i是外部for的一个变量,地址不变化。遍历完成后,最终i=10。 故go func执行时,i的值始终是10。 第二个go func中i是函数参数,与外部for中的i完全是两个变量。 尾部(i)将发生值拷贝,go func内部指向值拷贝地址。 4 下面代码会输出什么? type People struct{}func (p People)ShowA() {     fmt.Println("showA")     p.ShowB() } func(pPeople)ShowB() {     fmt.Println("showB") } typeTeacher struct {     People } func(t*Teacher)ShowB() {     fmt.Println("teachershowB") } funcmain() {     t := Teacher{}     t.ShowA() } 考点:go的组合继承 解答: 这是Golang的组合模式,可以实现OOP的继承。 被组合的类型People所包含的方法虽然升级成了外部类型Teacher这个组合类型的方法(一定要是匿名字段),但它们的方法(ShowA())调用时接受者并没有发生变化。 此时People类型并不知道自己会被什么类型组合,当然也就无法调用方法时去使用未知的组合者Teacher类型的功能。 showAshowB 5 下面代码会触发异常吗?请详细说明 func main() {     runtime.GOMAXPROCS(1)     int_chan := make(chanint, 1)     string_chan := make(chanstring, 1)     int_chan <- 1     string_chan <- "hello"     select {                case value := <-int_chan:        fmt.Println(value)           casevalue := <-string_chan:                   panic(value)     } } 考点:select随机性 解答: select会随机选择一个可用通用做收发操作。 所以代码是有肯触发异常,也有可能不会。 单个chan如果无缓冲时,将会阻塞。但结合 select可以在多个chan间等待执行。有三点原则: select 中只要有一个case能return,则立刻执行。 当如果同一时间有多个case均能return则伪随机方式抽取任意一个执行。 如果没有一个case能return则可以执行”default”块。 6 下面代码输出什么? funccalc(indexstring, a, bint) int {     ret := a+ b     fmt.Println(index,a, b, ret)     return ret } funcmain() {          a := 1     b := 2     defer calc("1", a,calc("10", a, b))    a = 0     defer calc("2", a,calc("20", a, b))    b = 1 } 考点:defer执行顺序 解答: 这道题类似第1题 需要注意到defer执行顺序和值传递 index:1肯定是最后执行的,但是index:1的第三个参数是一个函数,所以最先被调用 calc("10",1,2)==>10,1,2,3 执行index:2时,与之前一样,需要先调用calc("20",0,2)==>20,0,2,2 执行到b=1时候开始调用,index:2==>calc("2",0,2)==>2,0,2,2最后执行index:1==>calc("1",1,3)==>1,1,3,4 10 1 2 320 0 2 22 0 2 21 1 3 4 7 请写出以下输入内容 funcmain() {            s := make([]int,5)     s = append(s,1, 2, 3)     fmt.Println(s) } 考点:make默认值和append 解答: make初始化是由默认值的哦,此处默认值为0 [00000123] 大家试试改为: s := make([]int, 0) s = append(s, 1, 2, 3) fmt.Println(s)//[1 2 3] 8 下面的代码有什么问题? type UserAges struct {     ages map[string]int     sync.Mutex } func(uaUserAges)Add(name string, age int) {     ua.Lock()          deferua.Unlock()     ua.ages[name] = age } func(uaUserAges)Get(name string)int {           ifage, ok := ua.ages[name]; ok {                  return age     }         return-1 } 考点:map线程安全 解答: 可能会出现 fatal error: concurrent mapreadandmapwrite. 修改一下看看效果 func (ua *UserAges)Get(namestring)int {     ua.Lock()          deferua.Unlock()          ifage, ok := ua.ages[name]; ok {                   return age     }            return-1 } 9.   下面的迭代会有什么问题? func (set *threadSafeSet)Iter()<-chaninterface{} {     ch := make(chaninterface{})                  gofunc() {         set.RLock()                for elem := range set.s {            ch <- elem         }                   close(ch)         set.RUnlock()     }()      return ch } 考点:chan缓存池 解答: 看到这道题,我也在猜想出题者的意图在哪里。 chan?sync.RWMutex?go?chan缓存池?迭代? 所以只能再读一次题目,就从迭代入手看看。 既然是迭代就会要求set.s全部可以遍历一次。但是chan是为缓存的,那就代表这写入一次就会阻塞。 我们把代码恢复为可以运行的方式,看看效果 package main import (          "sync"     "fmt")//下面的迭代会有什么问题?type threadSafeSet struct {     sync.RWMutex     s []interface{} } func(set*threadSafeSet)Iter() <-chaninterface{} {     //ch := make(chan interface{}) // 解除注释看看!     ch := make(chaninterface{},len(set.s))    gofunc() {         set.RLock()        forelem,value := range set.s {            ch <- elem             println("Iter:",elem,value)         }       close(ch)         set.RUnlock()     }()     return ch } funcmain() {     th:=threadSafeSet{         s:[]interface{}{"1","2"},     }     v:=<-th.Iter()     fmt.Sprintf("%s%v","ch",v) } 10 以下代码能编译过去吗?为什么? package main import (   "fmt") typePeople interface {     Speak(string) string } typeStduent struct{} func(stu*Stduent)Speak(think string)(talk string) {     ifthink == "bitch" {         talk = "Youare a good boy"     } else {         talk = "hi"     }     return } funcmain() {     var peoPeople = Stduent{}     think := "bitch"    fmt.Println(peo.Speak(think)) } 考点:golang的方法集 解答: 编译不通过! 做错了!?说明你对golang的方法集还有一些疑问。 一句话:golang的方法集仅仅影响接口实现和方法表达式转化,与通过实例或者指针调用方法无关。 11 以下代码打印出来什么内容,说出为什么。 package main import (   "fmt") typePeople interface {     Show() } typeStudent struct{} func(stuStudent)Show() { } funclive()People {     var stuStudent     return stu } funcmain() {   if live() == nil {         fmt.Println("AAAAAAA")     } else {         fmt.Println("BBBBBBB")     } } 考点:interface内部结构 解答: 很经典的题! 这个考点是很多人忽略的interface内部结构。 go中的接口分为两种一种是空的接口类似这样: varininterface{} 另一种如题目: type People interface {     Show() } 他们的底层结构如下: type eface struct {      //空接口     _type _type        //类型信息     data  unsafe.Pointer //指向数据的指针(go语言中特殊的指针类型unsafe.Pointer类似于c语言中的void)} typeiface struct {      //带有方法的接口     tab  itab          //存储type信息还有结构实现方法的集合     data unsafe.Pointer  //指向数据的指针(go语言中特殊的指针类型unsafe.Pointer类似于c语言中的void)} type_type struct {     size       uintptr //类型大小     ptrdata    uintptr //前缀持有所有指针的内存大小     hash       uint32  //数据hash值     tflag     tflag     align      uint8   //对齐     fieldalign uint8   //嵌入结构体时的对齐     kind       uint8   //kind 有些枚举值kind等于0是无效的     alg       *typeAlg //函数指针数组,类型实现的所有方法     gcdata    *byte   str       nameOff     ptrToThis typeOff }type itab struct {     inter  *interfacetype //接口类型     _type  *_type         //结构类型     link   *itab     bad    int32     inhash int32     fun    [1]uintptr     //可变大小方法集合} 可以看出iface比eface 中间多了一层itab结构。 itab 存储_type信息和[]fun方法集,从上面的结构我们就可得出,因为data指向了nil 并不代表interface 是nil, 所以返回值并不为空,这里的fun(方法集)定义了接口的接收规则,在编译的过程中需要验证是否实现接口 结果: BBBBBBB 12.是否可以编译通过?如果通过,输出什么? func main() {     i := GetValue() switch i.(type) {          caseint:                println("int")            casestring:                println("string")            caseinterface{}:                println("interface")            default:                 println("unknown")     } } funcGetValue()int {    return1 } 解析 考点:type 编译失败,因为type只能使用在interface 13.下面函数有什么问题? func funcMui(x,y int)(sum int,error){     returnx+y,nil } 解析 考点:函数返回值命名 在函数有多个返回值时,只要有一个返回值有指定命名,其他的也必须有命名。 如果返回值有有多个返回值必须加上括号; 如果只有一个返回值并且有命名也需要加上括号; 此处函数第一个返回值有sum名称,第二个未命名,所以错误。 14.是否可以编译通过?如果通过,输出什么? package mainfunc main() {    println(DeferFunc1(1)) println(DeferFunc2(1)) println(DeferFunc3(1)) }func DeferFunc1(i int)(t int) {     t = i   deferfunc() {         t += 3     }() return t } funcDeferFunc2(i int)int {     t := i  deferfunc() {         t += 3     }() return t } funcDeferFunc3(i int)(t int) {   deferfunc() {         t += i     }() return2} 解析 考点:defer和函数返回值 需要明确一点是defer需要在函数结束前执行。 函数返回值名字会在函数起始处被初始化为对应类型的零值并且作用域为整个函数 DeferFunc1有函数返回值t作用域为整个函数,在return之前defer会被执行,所以t会被修改,返回4; DeferFunc2函数中t的作用域为函数,返回1;DeferFunc3返回3 15.是否可以编译通过?如果通过,输出什么? funcmain() {    list := new([]int)     list = append(list,1)     fmt.Println(list) } 解析 考点:new list:=make([]int,0) 16.是否可以编译通过?如果通过,输出什么? package mainimport "fmt"funcmain() {     s1 := []int{1, 2, 3}     s2 := []int{4, 5}     s1 = append(s1,s2)     fmt.Println(s1) } 解析 考点:append append切片时候别漏了'…' 17.是否可以编译通过?如果通过,输出什么? func main() {     sn1 := struct {         age  int         name string     }{age: 11,name: "qq"}     sn2 := struct {         age  int         name string     }{age: 11,name: "qq"}  if sn1== sn2 {         fmt.Println("sn1== sn2")     }     sm1 := struct {         age int         m   map[string]string     }{age: 11, m:map[string]string{"a": "1"}}     sm2 := struct {         age int         m   map[string]string     }{age: 11, m:map[string]string{"a": "1"}}             if sm1 == sm2 {         fmt.Println("sm1== sm2")     } } 解析 考点:结构体比较 进行结构体比较时候,只有相同类型的结构体才可以比较,结构体是否相同不但与属性类型个数有关,还与属性顺序相关。 sn3:= struct {     name string     age  int } {age:11,name:"qq"} sn3与sn1就不是相同的结构体了,不能比较。 还有一点需要注意的是结构体是相同的,但是结构体属性中有不可以比较的类型,如map,slice。 如果该结构属性都是可以比较的,那么就可以使用“==”进行比较操作。 可以使用reflect.DeepEqual进行比较 if reflect.DeepEqual(sn1, sm) {     fmt.Println("sn1==sm") }else {     fmt.Println("sn1!=sm") } 所以编译不通过: invalid operation: sm1 == sm2 18.是否可以编译通过?如果通过,输出什么? func Foo(x interface{}) {    if x== nil {         fmt.Println("emptyinterface")                 return     }     fmt.Println("non-emptyinterface") }        funcmain() {           var x *int = nil     Foo(x) } 解析 考点:interface内部结构 non-emptyinterface 19.是否可以编译通过?如果通过,输出什么? func GetValue(m map[int]string, id int)(string, bool) {              if _,exist := m[id]; exist {                    return"存在数据", true     }            returnnil, false}funcmain() {     intmap:=map[int]string{    1:"a",        2:"bb",        3:"ccc",     }     v,err:=GetValue(intmap,3)     fmt.Println(v,err) } 解析 考点:函数返回值类型 nil 可以用作 interface、function、pointer、map、slice 和 channel 的“空值”。但是如果不特别指定的话,Go 语言不能识别类型,所以会报错。报:cannot use nil as type string in return argument. 20.是否可以编译通过?如果通过,输出什么? const (     x = iota     y     z = "zz"     k     p = iota) funcmain()  {     fmt.Println(x,y,z,k,p) } 解析 考点:iota 结果: 0 1 zz zz 4 21.编译执行下面代码会出现什么? package mainvar(     size :=1024     max_size = size*2) funcmain() {     println(size,max_size) } 解析 考点:变量简短模式 变量简短模式限制: 定义变量同时显式初始化 不能提供数据类型 只能在函数内部使用 结果: syntaxerror: unexpected := 22.下面函数有什么问题? package main const cl = 100 var bl   = 123 funcmain() {     println(&bl,bl)    println(&cl,cl) } 解析 考点:常量 常量不同于变量的在运行期分配内存,常量通常会被编译器在预处理阶段直接展开,作为指令数据使用, cannot take the address of cl 23.编译执行下面代码会出现什么? package main funcmain() {     for i:=0;i<10;i++  {     loop:        println(i)     }    gotoloop } 解析 考点:goto goto不能跳转到其他函数或者内层代码 goto loop jumps intoblock starting at 24.编译执行下面代码会出现什么? package main import"fmt" funcmain() {      typeMyInt1 int      typeMyInt2 = int     var i int =9     var i1MyInt1 = i     var i2MyInt2 = i     fmt.Println(i1,i2) } 解析 考点:**Go 1.9 新特性 Type Alias ** 基于一个类型创建一个新类型,称之为defintion;基于一个类型创建一个别名,称之为alias。 MyInt1为称之为defintion,虽然底层类型为int类型,但是不能直接赋值,需要强转; MyInt2称之为alias,可以直接赋值。 结果: cannot use i (typeint) astype MyInt1 in assignment 25.编译执行下面代码会出现什么? package main import"fmt" typeUser struct { } typeMyUser1 User typeMyUser2 = User func(iMyUser1)m1(){     fmt.Println("MyUser1.m1") } func(iUser)m2(){     fmt.Println("User.m2") } funcmain() {     var i1MyUser1     var i2MyUser2     i1.m1()     i2.m2() } 解析 考点:**Go 1.9 新特性 Type Alias ** 因为MyUser2完全等价于User,所以具有其所有的方法,并且其中一个新增了方法,另外一个也会有。 但是 i1.m2() 是不能执行的,因为MyUser1没有定义该方法。 结果: MyUser1.m1User.m2 26.编译执行下面代码会出现什么? package main import"fmt" type T1 struct { } func(tT1)m1(){     fmt.Println("T1.m1") } type T2= T1 typeMyStruct struct {     T1     T2 } funcmain() {     my:=MyStruct{}     my.m1() } 解析 考点:**Go 1.9 新特性 Type Alias ** 是不能正常编译的,异常: ambiguousselectormy.m1 结果不限于方法,字段也也一样;也不限于type alias,type defintion也是一样的,只要有重复的方法、字段,就会有这种提示,因为不知道该选择哪个。 改为: my.T1.m1() my.T2.m1() type alias的定义,本质上是一样的类型,只是起了一个别名,源类型怎么用,别名类型也怎么用,保留源类型的所有方法、字段等。 27.编译执行下面代码会出现什么? package main import (           "errors"     "fmt") varErrDidNotWork = errors.New("did not work") funcDoTheThing(reallyDoItbool)(errerror) {     ifreallyDoIt {         result, err:= tryTheThing()         if err!= nil || result != "it worked" {            err = ErrDidNotWork         }     }    return err } functryTheThing()(string,error) {     return"",ErrDidNotWork } funcmain() {     fmt.Println(DoTheThing(true))     fmt.Println(DoTheThing(false)) } 解析 考点:变量作用域 因为 if 语句块内的 err 变量会遮罩函数作用域内的 err 变量,结果: 改为: func DoTheThing(reallyDoIt bool)(errerror) {     varresult string     ifreallyDoIt {         result, err =tryTheThing()         if err!= nil || result != "it worked" {            err = ErrDidNotWork         }     }    return err } 28.编译执行下面代码会出现什么? package main functest() []func() {     varfuns []func()     fori:=0;i<2;i++  {         funs = append(funs,func() {                       println(&i,i)         })     }    returnfuns } funcmain(){     funs:=test()            for_,f:=range funs{         f()     } } 解析 考点:闭包延迟求值 for循环复用局部变量i,每一次放入匿名函数的应用都是想一个变量。 结果: 0xc042046000 2 0xc042046000 2 如果想不一样可以改为: func test() []func()  {     varfuns []func()     fori:=0;i<2;i++  {         x:=i         funs = append(funs,func() {            println(&x,x)         })     }    returnfuns } 29.编译执行下面代码会出现什么? package main functest(x int)(func(),func()) {     returnfunc() {        println(x)     x+=10     }, func() {              println(x)     } } funcmain() {     a,b:=test(100)     a()     b() } 解析 考点:闭包引用相同变量* 结果: 100 110 30. 编译执行下面代码会出现什么? package main im port (   "fmt"     "reflect") funcmain1() {     deferfunc() {      iferr:=recover();err!=nil{           fmt.Println(err)        }else {           fmt.Println("fatal")        }     }()     deferfunc() {        panic("deferpanic")     }()     panic("panic") } funcmain() {     deferfunc() {        iferr:=recover();err!=nil{            fmt.Println("++++")            f:=err.(func()string)             fmt.Println(err,f(),reflect.TypeOf(err).Kind().String())         }else {            fmt.Println("fatal")         }     }()     deferfunc() {        panic(func()string {            return "defer panic"         })     }()     panic("panic") } 解析 考点:panic仅有最后一个可以被revover捕获 触发panic("panic")后顺序执行defer,但是defer中还有一个panic,所以覆盖了之前的panic("panic") 原文链接:https://blog.csdn.net/itcastcpp/article/details/80462619

剑曼红尘 2020-03-09 10:46:30 0 浏览量 回答数 0

问题

DIYRubyCPU分析——PartI

sunny夏筱 2019-12-01 21:55:37 7137 浏览量 回答数 0

问题

shiro报错 There is no session with id [xxx] ?报错

爱吃鱼的程序员 2020-06-14 14:52:58 0 浏览量 回答数 1

回答

背景 Cromwell 的 Call Caching 功能如何开启和关闭? 在一些场景下,提交工作流时不想使用 Call Caching,需要无条件执行,该如何设置? 工作流重新提交后,有一些 task 预期不需要重新执行,但依然执行了,Call Caching 疑似没有生效,怎么查看原因? 本篇文档将对 Call Caching 的使用做一个详细的介绍,包括功能的开启和关闭、如何通过查看元数据的方式,确认 Call Caching 未生效的原因等。 Call Caching 设置 配置文件中设置全局 Call Caching 开关状态 如果要使用 Cromwell 的 Call Caching 功能,需要在 Server 的配置文件中设置: call-caching { # Allows re-use of existing results for jobs you have already run # (default: false) enabled = true # Whether to invalidate a cache result forever if we cannot reuse them. Disable this if you expect some cache copies # to fail for external reasons which should not invalidate the cache (e.g. auth differences between users): # (default: true) invalidate-bad-cache-results = true } call-caching.enabled 是 Call Caching 功能的开关,可以按照自己的需求开启和关闭。 在 Option 中设置单个 Workflow 是否使用 Call Caching 在 Call Caching 功能全局开启的状态下,提交工作流时,可以通过携带如下两个 option 选项设置本次执行是否使用 Call Caching: { "write_to_cache": true, "read_from_cache": true } write_to_cache: 表示本次 workflow 执行结果是否写入 Cache,实际上就是是否给后面的工作流复用。默认是 true。 read_from_cache: 表示本次 workflow 执行是否从 Cache 中读取之前的结果,也就是是否复用以前的结果,默认是 true,如果设置为 false,表示本次执行不使用 Call Caching,强制执行。 查看元数据 工作流执行时,每一个 task 的每一个 call(对应批量计算的一个作业)都会有 metadata,记录了这个步骤的运行过程,当然也包括 Call Caching 的详细信息,通过下面的命令可以查询一个工作流的 metadata: widdler query -m [WorkflowId] 在元数据信息中找到对应的 task 的详细信息,比如: { "callRoot": "oss://gene-test/cromwell_test/GATK4_VariantDiscovery_pipeline_hg38/53cfd3fc-e9d5-4431-83ec-be6c51ab9365/call-HaplotypeCaller/shard-10", "inputs": { "gatk_path": "/gatk/gatk", "ref_fasta": "oss://genomics-public-data-shanghai/broad-references/hg38/v0/Homo_sapiens_assembly38.fasta", "cluster_config": "OnDemand ecs.sn2ne.xlarge img-ubuntu-vpc", "input_bam_index": "oss://gene-test/cromwell_test/GATK4_VariantDiscovery_pipeline_hg38/cf55a2d1-572c-4490-8edf-07656802a79b/call-GatherBamFiles/NA12878.hg38.ready.bam.bai", "output_filename": "NA12878.hg38.vcf.gz", "contamination": null, "ref_fasta_index": "oss://genomics-public-data-shanghai/broad-references/hg38/v0/Homo_sapiens_assembly38.fasta.fai", "ref_dict": "oss://genomics-public-data-shanghai/broad-references/hg38/v0/Homo_sapiens_assembly38.dict", "interval_list": "/home/data/GATK_human_genome_resource_bundle/hg38_from_GCP/hg38_wgs_scattered_calling_intervals/temp_0047_of_50/scattered.interval_list", "input_bam": "oss://gene-test/cromwell_test/GATK4_VariantDiscovery_pipeline_hg38/cf55a2d1-572c-4490-8edf-07656802a79b/call-GatherBamFiles/NA12878.hg38.ready.bam.bam", "docker_image": "registry.cn-shanghai.aliyuncs.com/wgs_poc/poc:4.0.10.1" }, "returnCode": 0, "callCaching": { "allowResultReuse": true, "hashes": { "output expression": { "File output_vcf_index": "A162250CB6F52CC32CB75F5C5793E8BB", "File output_vcf": "7FD061EEA1D3C63912D7B5FB1F3C5218" }, "runtime attribute": { "userData": "N/A", "docker": "F323AFFA030FBB5B352C60BD7D615255", "failOnStderr": "68934A3E9455FA72420237EB05902327", "imageId": "N/A", "continueOnReturnCode": "CFCD208495D565EF66E7DFF9F98764DA" }, "output count": "C81E728D9D4C2F636F067F89CC14862C", "input count": "D3D9446802A44259755D38E6D163E820", "command template": "9104DF40289AB292A52C2A753FBF58D2", "input": { "File interval_list": "04dc2cb895d13a40657d5e2aa7d31e8c", "String output_filename": "2B77B986117FC94D088273AD4D592964", "File ref_fasta": "9A513FB0533F04ED87AE9CB6281DC19B-400", "File input_bam_index": "D7CA83047E1B6B8269DF095F637621FE-1", "String gatk_path": "EB83BBB666B0660B076106408FFC0A9B", "String docker_image": "0981A914F6271269D58AA49FD18A6C13", "String cluster_config": "B4563EC1789E5EB82B3076D362E6D88F", "File ref_dict": "3884C62EB0E53FA92459ED9BFF133AE6", "File input_bam": "9C0AC9A52F5640AA06A0EBCE6A97DF51-301", "File ref_fasta_index": "F76371B113734A56CDE236BC0372DE0A" }, "backend name": "AE9178757DD2A29CF80C1F5B9F34882E" }, "effectiveCallCachingMode": "ReadAndWriteCache", "hit": false, "result": "Cache Miss" }, "stderr": "oss://gene-test/cromwell_test/GATK4_VariantDiscovery_pipeline_hg38/53cfd3fc-e9d5-4431-83ec-be6c51ab9365/call-HaplotypeCaller/shard-10/stderr", "shardIndex": 10, "stdout": "oss://gene-test/cromwell_test/GATK4_VariantDiscovery_pipeline_hg38/53cfd3fc-e9d5-4431-83ec-be6c51ab9365/call-HaplotypeCaller/shard-10/stdout", "outputs": { "output_vcf": "oss://gene-test/cromwell_test/GATK4_VariantDiscovery_pipeline_hg38/53cfd3fc-e9d5-4431-83ec-be6c51ab9365/call-HaplotypeCaller/shard-10/NA12878.hg38.vcf.gz", "output_vcf_index": "oss://gene-test/cromwell_test/GATK4_VariantDiscovery_pipeline_hg38/53cfd3fc-e9d5-4431-83ec-be6c51ab9365/call-HaplotypeCaller/shard-10/NA12878.hg38.vcf.gz.tbi" }, "commandLine": "set -e\n\n /gatk/gatk --java-options "-Xmx4g -Xmx4g" \\n HaplotypeCaller \\n -R /cromwell_inputs/73a7571e/Homo_sapiens_assembly38.fasta \\n -I /cromwell_inputs/02f1b5ca/NA12878.hg38.ready.bam.bam \\n -L /home/data/GATK_human_genome_resource_bundle/hg38_from_GCP/hg38_wgs_scattered_calling_intervals/temp_0047_of_50/scattered.interval_list \\n -O NA12878.hg38.vcf.gz \\n -contamination 0", "attempt": 1, "jobId": "job-000000005DB051A800006F970001CAC8", "start": "2019-10-25T02:38:03.522Z", "backendStatus": "Finished", "runtimeAttributes": { "cluster": "Right(AutoClusterConfiguration(OnDemand,ecs.sn2ne.xlarge,img-ubuntu-vpc,None,None,None))", "continueOnReturnCode": "0", "failOnStderr": "false", "vpc": "BcsVpcConfiguration(Some(10.20.200.0/24),Some(vpc-uf61zj30k0ebuen0xi7ci))", "mounts": "BcsInputMount(Right(nas://10.20.66.4:/data/ali_yun_test/),Left(/home/data),true)", "docker": "BcsDockerWithoutPath(registry.cn-shanghai.aliyuncs.com/wgs_poc/poc:4.0.10.1)", "autoReleaseJob": "false", "maxRetries": "0" }, "executionStatus": "Done", "end": "2019-10-25T03:22:23.481Z", "executionEvents": [ { "endTime": "2019-10-25T03:22:21.626Z", "description": "RunningJob", "startTime": "2019-10-25T02:38:03.645Z" }, { "endTime": "2019-10-25T03:22:22.481Z", "description": "UpdatingCallCache", "startTime": "2019-10-25T03:22:21.626Z" }, { "endTime": "2019-10-25T02:38:03.645Z", "description": "CallCacheReading", "startTime": "2019-10-25T02:38:03.643Z" }, { "endTime": "2019-10-25T02:38:03.522Z", "description": "Pending", "startTime": "2019-10-25T02:38:03.522Z" }, { "endTime": "2019-10-25T02:38:03.542Z", "description": "WaitingForValueStore", "startTime": "2019-10-25T02:38:03.542Z" }, { "endTime": "2019-10-25T03:22:23.481Z", "description": "UpdatingJobStore", "startTime": "2019-10-25T03:22:22.481Z" }, { "endTime": "2019-10-25T02:38:03.643Z", "description": "PreparingJob", "startTime": "2019-10-25T02:38:03.542Z" }, { "endTime": "2019-10-25T02:38:03.542Z", "description": "RequestingExecutionToken", "startTime": "2019-10-25T02:38:03.522Z" } ], "backend": "BCS" } 在上面的元数据中,有一项 callCaching,主要记录了如下信息: allowResultReuse:是否允许其他工作流复用。 如果当前工作流设置了不允许写入 Cache,则不可以复用 如果当前工作流设置了允许写入 Cache,则只有任务执行成功,才允许复用 hashes:当前任务的输入、输出、运行时等参数的 hash 记录,用于比对两次运行条件是否一样。 effectiveCallCachingMode:Call Caching 的模式,比如是否从 Cache 中读取,或者是否写入 Cache 等。 hit:当前任务在 Cache 是否命中。 result:当前任务在 Cache 中命中的详情,比如哪个工作流的哪个 task 的哪个 shard。 综合上面的解释,我们看到实例中的这个 call, 是 GATK4_VariantDiscovery_pipeline_hg38 这个工作流的 HaplotypeCaller 这个 task 的10号 shard,Call Cache 情况如下: 未在 Cache 中命中,完整的执行了一次 执行成功,可以允许后的流程复用 Call Caching 未生效问题排查 如果遇到不符合预期的 task,可以通过如下步骤排查原因: 查看当前 workflow 重新执行的 task 的 Call Caching 元数据 如果当前 task 的 Call Caching 的模式是不使用Cache(可能是提交作业时设置了不使用 Call Caching 的选项),则不会去利用之前的结果,确实会强制重新执行,是符合预期的 如果当前 task 未命中 Cache,则需要查看之前的 workflow, 进一步确认未命中的原因 查看之前的 workflow 的 task 的 CalCaching 元数据,确认之前的 task 是否执行成功,是否可以复用 如果之前的 task 的 不允许复用,可能是执行失败了,或者虽然执行成功,但 Cache 模式设置的不写入 Cache,即不允许复用 如果之前的 task 允许复用,但未命中,则需要比较两次的 hash 记录,可能是由于 Call Caching 相关的参数变化引起的 背景 Cromwell server 的启动需要以下组件配合: 启动 Mysql 的 docker 容器作为 Crowmell 的持久化数据库,包括配置用户名,密码等 填写 Cromwell 配置文件,包括 BCS 后端配置及数据库等配置 使用 Cromwell 的 jar 包,启动 server 实际上 Cromwell 除了发布 jar 包,也会发布对应的 docker 镜像,我们可以考虑使用 docker-compose来简化以上步骤。docker-compose 是 Docker 官方的开源项目,其定位是定义和运行多个 Docker 容器的应用(Defining and running multi-container Docker applications)。 使用docker-compose 可以将容器化的 Cromwell 和 Mysql 两个 service 拉起,作为一个应用来运行。再配合脚本来简化配置,可以将 Cromwell 的服务做成一键启停。 开通 ECS 作为 Crowmell server 首先使用 Cromwell server 镜像开通一台 ECS,ssh 登入机器后,可以运行目录下的cromwell-server.sh,进行Cromwell Server的管理: ./cromwell-server.sh cromwell-server.sh - init cromwell config and start/stop service Usage: cromwell-server.sh [options...] [init/start/stop/status] Options: --id=STRING Access id --key=STRING Access key --root=STRING Oss root for cromwell, e.g: oss://my-bucket/cromwell/ --instance=STRING default runtime: instance type [ecs.sn1.medium] --image=STRING default runtime: image id [img-ubuntu-vpc] 第一次配置与启动服务 初次使用,需要做一些初始配置,可以使用下面的命令完成一键初始化与启动: ./cromwell-server.sh init --id=LTAI8xxxxx --key=vVGZVE8qUNjxxxxxxxx --root=oss://gtx-wgs-demo/cromwell/ 上面的命令完成了以下配置: --id: 批量计算的 Access Id --key: 批量计算的 Access Key --root: Crowmell 运行时在 OSS 上的工作根目录 --instance: Cromwell 默认运行时参数,实例类型 --image: Cromwell 默认运行时参数,镜像ID执行完以上命令后,会根据 Crowmell 配置文件模板生成配置文件,并通过 docker-compose 启动 Cromwell server,并在后台运行。 服务启动后,就可以通过镜像中的命令行工具 widdler 执行工作流的提交: cd /home/cromwell/cromwell/ widdler run echo.wdl inputs.json -o bcs_workflow_tag:test_echo 停止服务 使用下面的命令可以一键停止服务: ./cromwell-server stop 再次启动服务 在已经完成配置的情况下,使用下面的命令,可以完成服务启动: ./cromwell-server start 重新配置并启动服务 如果需要修改配置,在服务停止的情况下,再次使用 init 命令可以完成新配置重新启动: ./cromwell-server.sh init --id=LTAI8xxxxx --key=vVGZVE8qUNjxxxxxxxx --root=oss://gtx-wgs-demo/cromwell/ 使用option文件设置默认运行时参数 在 Crowmell 的配置文件中,可以设置每个 backend 的默认运行时参数 default-runtime-attibutes,也可以在提交工作流时通过 option 覆盖原有设置。 所以如果您在提交工作流时用到了数据盘、NAS等,都可以在 option 文件中设置: { "default_runtime_attributes": { "vpc": "192.168.0.0/24", "autoReleaseJob": true, "mounts": "nas://1f****04-xkv88.cn-beijing.nas.aliyuncs.com:/ /mnt/ true", "dataDisk": "cloud_ssd 250 /home/mount/" }, "bcs_workflow_tag": "Tagxxx", "read_from_cache": true } 使用 widdler 命令行的 -O (大写的O)参数提交 option 文件: widdler run echo.wdl inputs.json -O options.json 在 Cromwell Server 配置完成后,如何快捷的进行提交、停止工作流、流程失败后如何快速定位问题以及工作流完成后如何如何快速查看运行日志、查看工作流的 Metrics 信息、工作流产生的费用等手段,这些问题就变成了 server 运维工作的基本诉求。 Cromwell 以 server 的方式运行后是支持通过 API 接口获取以上信息的,但是有二次开发的工作量;而 widdler 是针对 Cromwell Server API 接口开发的命令行工具,通过 widdler 命令行工具减少运维成本。 本文主要介绍阿里云对 widdler 工具的扩展,通过 widdler 工具查询指定工作流的作业运行状态、后端引擎的运行时信息、费用查询、问题定位调查以及子任务日志查看等功能。 widdler 安装 widdler 默认在阿里云批量计算提供的 Cromwell server 镜像中安装。可以直接使用,无需做安装操作。 配置 widdler 由于涉及到个人阿里云运行数据的查询,需要在使用之前设置对应账号的 AK 信息、以及后端执行引擎所部署的region信息。 config 命令格式: widdler config -i id -k key -r cn-zhangjiakou 3. 校验 WDL 提交工作流之前对 WDL 做语法校验,排除部分低级问题;减少后续提交工作流后由于低级问题导致的流程失败。 validate 命令格式: widdler validate echo.wdl inputs.json 4. 提交工作流 run 命令格式: widdler run echo.wdl inputs.json -l test 其中:test 为 label,可以根据样本进行打标签,后续可以按 label 做过滤。 终止工作流 命令格式: widdler abort workflowId abort 获取工作流 6.1 获取工作流列表 命令格式: widdler query query 其中:默认获取当前 user 7 天内的工作流信息;可以根据 user label等信息来筛选工作流信息;其他使用方法参考 help 信息。 6.2 获取工作流 Meta 命令格式: widdler query workflowId 7. 获取工作流运行状态 命令格式: widdler describe workflowId describe 其中:”stepName” 表示工作流的某个自步骤的名称;”status” 表示当前步骤的运行状态”成功、失败、运行中”;”progress” 表示当前步骤的进度,如”4/4” 表示当前步骤存在4个子任务全部执行完成; 若是”2/4” 则表示当前步骤存在4个任务,已经完成2个。”elapse”表示当前步骤的所有子任务执行总耗时时间(不包括机器的启动时间); “coretime”表示当前步骤所有子任务消耗的核时时间(不包括机器的启动时间)。 命令格式: widdler describe workflowId -t stepName subdescribe shardIndex 是 Cromwell 将每个 task 的子任务按 shardIndex 做索引,对应的是批量计算的一个作业。通过该命令可以看到指定 task 对应的统计信息。 获取工作流统计信息 命令格式: widdler stat workflowId stat 其中:”cpuCore” 表示当前步骤中使用对应实例的 CPU 核数,”cpuUsage” 表示当前步骤所有任务从开始到当前(若当前任务结束状态则表示从开始到结束)的 CPU 平均利用率;”memSize” 表示当前步骤中使用对应实例的内存大小,”memUsage” 表示当前步骤中所有任务从开始到当前的MEM平均利用率;”sysDisk” 表示当前步骤实例的系统盘大小(默认 40GB),”sysDiskUsage” 表示当前步骤的所有任务在当前时间点的磁盘平均利用率;”dataDisk” 表示实例的数据盘大小(默认没有),”dataDiskUsage” 表示当前步骤的所有任务在当前时间点的磁盘平均利用率。 命令格式: widdler stat workflowId -t stepName substat 查询某个步骤对应的 Metrics 信息;可能某个步骤存在多个 scatter,那么每个 scatter 运行情况如何,则可以通过本命令获取到。 获取工作流费用 命令格式: widdler billing workflowId newbill 获取工作流运行日志 命令格式: widdler log workflowId 通过 log 查询命令,可以查看工作流的实际运行情况,执行过程是否符合预期可以通过该命令做到一键查看。stdout 以及 stderr 日志小于 1MB 的,会直接在屏幕上显示出来;超过 1MB 的需要借助 OSS 工具查看。 log 工作流问题定位 命令格式: widdler explain workflowId 通过该命令可以一键查询工作流失败的原因,展示出现问题的步骤,输出该步骤的对应失败任务的 stdout 以及 stderr 信息,快速排查问题。 explain 更多其他功能请参考 widdler 的帮助信息

1934890530796658 2020-03-28 21:40:48 0 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 企业建站模板