main函数

上篇和中篇讲解了什么是GCD，如何使用GCD，这篇文章将讲解使用GCD中将遇到的死锁问题。有兴趣的朋友可以回顾《 iOS多线程开发之GCD（上篇） 》和《 iOS多线程开发之GCD（中篇） 》。 言归正传，我们首先来回顾下死锁，所谓死锁: 是指两个或两个以上的进程（线程）在执行过程中，因争夺资源（如数据源，内存等，变量不是资源）而造成的一种互相等待的现象，若无外部处理作用，它们都将无限等待下去。 　　死锁形成的原因： 系统资源不足 进程（线程）推进的顺序不恰当； 资源分配不当 　　死锁形成的条件： 互斥条件： 所谓互斥就是进程在某一时间内独占资源。 请求与保持条件： 一个进程因请求资源而阻塞时，对已获得的资源保持不放。 不剥夺条件： 进程已获得资源，在末使用完之前，不能强行剥夺。 循环等待条件： 若干进程之间形成一种头尾相接的循环等待资源关系。 在GCD中，主要的死锁就是当前串行队列里面同步执行当前串行队列。解决的方法就是将同步的串行队列放到另外一个线程执行。 在举例说明之前，我们先来回顾下GCD的中的任务派发和队列。 （1）任务派发 任务派发方式 说明 dispatch_sync() 同步执行，完成了它预定的任务后才返回，阻塞当前线程 dispatch_async() 异步执行，会立即返回，预定的任务会完成但不会等它完成，不阻塞当前线程 （2）队列种类 队列种类 说明 串行队列

python 装饰器 1、必备 1 2 3 4 5 6 7 8 9 10 11 12 13 14 #### 第一波 #### def foo(): print 'foo' foo #表示是函数 foo() #表示执行foo函数 #### 第二波 #### def foo(): print 'foo' foo = lambda x: x + 1 foo() # 执行下面的lambda表达式，而不再是原来的foo函数，因为函数 foo 被重新定义了 2、需求来了 初创公司有N个业务部门，1个基础平台部门，基础平台负责提供底层的功能，如：数据库操作、redis调用、监控API等功能。业务部门使用基础功能时，只需调用基础平台提供的功能即可。如下： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 ############### 基础平台提供的功能如下 ############### def f1(): print 'f1' def f2(): print 'f2' def f3(): print 'f3' def f4(): print 'f4' ############### 业务部门A 调用基础平台提供的功能 ############### f1() f2() f3() f4() ######

一：函数 1.什么是函数呢 ？ 就是在不断进行加法运算时，为了提高代码的复用性，就把该功能封装为一段独立的小程序，当下次需要执行加法运算的时候，就可以直接调用这段小程序，那么这种封装形式的具体表现则称之为函数 例如 public class dame{ 　　　　public static void main(String[] args){ 　　　　int a = 4+5; 　　　　　　 System.out.println("a="+a); 　　　　　　int b = 3+9; 　　　　　　 System.out.println("b="+b); 　　　　　 add(4,5); 　　　　 } 　　　　public static int add(int a, int b){ 　　　　　　 return a+b; 　　　　} } 2.函数的格式 修饰符 返回值类型 函数名(参数类型 形式参数1，参数类型 形式参数2 , ......){ 执行语句； return 返回值； } 参数类型： 运行这段程序得出的一个运算结果，结果类型，如果函数没有返回值则用 void 来表示该函数没有返回值 函数名：仅仅是一个标识符，可以随意起名字 。 形式参数： 是一个变量，用于存储函数传递进来的实际参数 实际测试：传递给形式参数的具体数值 返回值：返回给调用者的 a:定义函数 1.是否有未知内容参与运算

Part1 #include <stdio.h> const int N=5; int main() { int a[N] = {1, 2, 3, 4, 5}; int i; for(i=0; i<N; i++) printf("%d: %d\n", &a[i], a[i]); return 0; } #include <stdio.h> const int N=5; int main() { char a[5] = {'h','e','l','l','o'}; int i; for(i=0; i<N; i++) printf("%d: %c\n", &a[i], a[i]); return 0; } #include <stdio.h> const int N=5; int main() { double a[5] = {1.0, 2.0, 3.0, 4.0, 5.0}; int i; for(i=0; i<N; i++) printf("%d: %.2f\n", &a[i], a[i]); return 0; } Part2 #include <stdio.h> int main() { int a[5]; a[0] = 1; a[1] = 9; a[2] = 8; a[3] = 6; a[4] = 0; printf("a[0] = %d\n", a[0]); printf(

go 并发 说明 有人把go比作是21世纪的c语言，第一是因为go的设计比较简单，第二，21世纪最重要的就是并发程序设计，而go从语言层面就支持并发。 与此同时，并发程序的内存管理是非常复杂的，而在go中提供了垃圾回收的机制。 Go语言为并发编程而内置的上层API基于顺序通信进程模型CSP(communicating sequential processes)。这就意味着显式锁都是可以避免的，因为Go通过相对安全的通道发送和接受数据以实现同步，这大大地简化了并发程序的编写。 Go语言中的并发程序主要使用两种手段来实现。goroutine和channel。 goroutine goroutine是go并发编程的核心，说到底，goroutine就是协程，比线程更小，go语言在内部帮忙实现了goroutine之间的内存共享。执行goroutine只需要极少的栈内存(大概4-5kb)，当然会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。 一般情况下，一个普通计算机跑几十个线程就有点负载过大了，但是同样的机器却可以轻松地让成百上千个goroutine进行资源竞争。 使用 想要创建一个goroutine，只需要在普通函数的前面加一个go关键字，就可以创建并发执行单元。 在并发编程中，我们通常想将一个过程切分成几块

一个小玩意，main goroutine将计算菲波那契数列的第45个元素值。由于计算函数使用低效的递归，所以会运行相当长时间，在此期间我们想让用户看到一个可见的标识来表明程序依然在正常运行，所以来做一个动画的小图标： package main import ( "fmt" "time" ) func main() { go spinner(100 * time.Millisecond) const n = 45 fibN := fib(n) // slow fmt.Printf("\rFibonacci(%d) = %d\n", n, fibN) } func spinner(delay time.Duration) { for { for _, r := range `-\|/` { fmt.Printf("\r%c Caculating...", r) time.Sleep(delay) } } } func fib(x int) int { if x < 2 { return x } return fib(x-1) + fib(x-2) } 来源： https://www.cnblogs.com/janeysj/p/12530702.html

坑1、整数比较的坑 在Python中一切都是对象，整数也是对象，在比较两个整数时有两个运算符“==”和“is”，它们的区别是： ·is比较的是两个整数对象的id值是否相等，也就是比较两个引用是否代表了内存中同一个地址。 ·==比较的是两个整数对象的内容是否相等，使用==时其实是调用了对象的__eq__()方法。 知道了is和==的区别之后，我们可以来看看下面的代码，了解Python中整数比较有哪些坑： #! /usr/bin/env python3 # -*- coding:utf-8 -*- # Author : Ma Yi # Blog : http://www.cnblogs.com/mayi0312/ # Date : 2020-03-19 # Name : test01 # Software : PyCharm # Note : 整数比较的坑 def main(): x = y = -1 while True: x += 1 y += 1 if x is y: print("%d is %d" % (x, y)) else: print("Attention! %d is not %d" % (x, y)) break x = y = 0 while True: x -= 1 y -= 1 if x is y: print("%d is %d" % (x, y))

在 java中要想实现多线程，有两种手段，一种是继续 Thread类，另外一种是实现 Runable接口。 对于直接继承 Thread的类来说，代码大致框架是： class 类名 extends Thread{ 方法1; 方法2； … public void run(){ // other code… } 属性1； 属性2； … } 先看一个简单的例子： /** * @author Hashsound 继承Thread类,直接调用run方法 * */ class hello extends Thread { private String name; public hello() { } public hello(String name) { this.name = name; } public void run() { for (int i = 0; i < 5; i++) { System.out.println(name + "运行 " + i); } } public static void main(String[] args) { hello h1 = new hello("A"); hello h2 = new hello("B"); h1.run(); h2.run(); } } 【运行结果】： A运行 0 A运行 1 A运行 2 A运行 3 A运行 4 B运行 0

1.数组与指针 　　一个变量有地址，一个数组包含若干元素，每个数组元素都在内存中占用存储单元，它们都有相应的地址。 　　指针变量既然可以指向变量，当然也可以指向数组元素（把某一元素的地址放到一个指针变量中）。 　　所谓数组元素的指针就是数组元素的地址。 2.指向数组元素的指针 　　定义一个指向数组元素的指针变量的方法，与以前介绍的指向变量的指针变量相同。 　　例如： 　　int a[10];(定义ａ为包含10个整型数据的数组) 　　int *p; (定义ｐ为指向整型变量的指针变量)。 　　应当注意，如果数组为int型，则指针变量的基类型亦应为int型。 3.下面是对该指针变量赋值： 　　p = ＆a[0]；把a[0]元素的地址赋给指针变量ｐ。 也就是使ｐ指向ａ数组的第０号元素，见图 -->> 4.通过指针引用数组元素： 　　引用一个数组元素，可以用： 　　（１） 下标法，如 a[i] 形式； 　　（２） 指针法，如*(a+i)或*(p+i)。 　　其中的ａ是数组名，ｐ是指向数组元素的指针变量，其初值 ｐ＝ａ。 　　注意：数组名即“翻译成数组的第一个元素的地址！ 例题： 输出数组中的全部元素 假设有一个ａ数组，整型，有10个元素。要输出各元素的值有三种方法： (1) 下标法 #include <stdio.h> void main() { int a[10]; int i; for(

线程和进程 进程定义 进程指正在运行的程序 确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。（比如电脑中运行的酷狗,qq等） 线程定义 线程是进程中的一个执行单元，负责当前进程中程序的执行，线程共享进程的资源。 线程与进程的关系 一个程序运行后至少有一个进程，一个进程中可以包含多个线程。 主线程 jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。 多线程定义 即就是一个程序中有多个线程在同时执行。多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高。提到多线程就要提到两个概念：串行/并行 串行 单个线程执行多个任务。比如下载文件,第一个没下完不能开始下载第二个，属于不同时刻。缺点很明显，效率很低。 并行 多个线程执行多个任务。比如开启迅雷同时下载好几个文件，属于同一时刻。效率很高，但是要注意不要每个任务都建一个线程去处理，任务数量越多，内存压力越大，严重会导致宕机。 程序运行原理 分时调度 所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。 抢占式调度 优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个线程（线程随机性），java使用的为抢占式调度。 使用线程和不适用线程的区别