1：template编程风格

• 它是标准模板库（STL）的基础
• 参数化技术

BIP - 0070 详解

  BIP: 70
  Layer: Applications
  Title: 支付协议
  Author: Gavin Andresen <gavinandresen@gmail.com>
          Mike Hearn <mhearn@bitcoinfoundation.org>
  Comments-Summary: No comments yet.
  Comments-URI: https://github.com/bitcoin/bips/wiki/Comments:BIP-0070
  Status: Final
  Type: Standards Track
  Created: 2013-07-29

摘要

这个BIP描述了一个商家和他们的客户之间的通信协议，使客户更好的体验和更好的安全性，以抵抗付款过程中的中间人攻击。

动机

当前，最小比特币支付协议的操作如下：

1. 客户将物品添加到网上购物篮，并决定使用比特币支付。
2. 商家生成一个唯一的付款地址，将其与客户的订单相关联，并要求客户支付。
3. 客户从商家的网页上复制比特币地址，并将其粘贴到他们正在使用的任何钱包中，或者遵循比特币链接，并且他们的钱包将以支付的金额启动。
4. 客户授权支付商户的地址，并通过比特币P2P网络广播交易。
5. 商户的服务器检测到付款，并在充分的交易确认后认为交易最终。

这个BIP扩展了上述协议，以支持几个新的功能：

1. 人类可读，安全的支付目的地 - 客户将被要求授权支付给“example.com”，而不是一个难以辨认的，34个字符的比特币地址。
2. 安全的付款证明，客户可以在与商家发生纠纷的情况下使用。
3. 在交易获得硬件钱包授权之前，用中间人攻击来抵御商人的比特币地址和攻击者的地址。
4. 付款收到的消息，所以客户立即知道商家已经收到，并已经处理（或正在处理）他们的付款。
5. 退款地址由客户的钱包软件自动提供给商户，因此商家在退款超额付款或因某种原因无法完成的订单前不必联系客户。

协议

这个BIP描述使用Google Protocol Buffers编码的支付协议消息，使用X.509证书进行验证，并通过http / https进行通信。 未来的BIP可能会将此支付协议扩展到其他编码，PKI系统或传输协议。

支付协议由三个消息组成; PaymentRequest，Payment和PaymentACK，并以某种方式从客户开始指示他们准备付款，商家的服务器用PaymentRequest消息响应：

消息

Protocol Buffers消息在 paymentrequest.proto https://github.com/bitcoin/bips/blob/d2a8fb089d7010d839530f879e07edc4e48b84fa/bip-0070/paymentrequest.proto 中定义。

Output

PaymentRequest消息中使用输出来指定应该发送付款（或付款的一部分）的位置。 它们也用于支付消息来指定退款的发送地点。

    message Output {
    optional uint64 amount = 1 [default = 0];
        optional bytes script = 2;
    }

PaymentDetails/PaymentRequest

支付请求被分成两个消息以支持未来的可扩展性。 大部分信息都包含在PaymentDetails消息中。 它被包裹在PaymentRequest消息中，其中包含关于商家和数字签名的元信息。

    message PaymentDetails {
        optional string network = 1 [default = "main"];
        repeated Output outputs = 2;
        required uint64 time = 3;
        optional uint64 expires = 4;
        optional string memo = 5;
        optional string payment_url = 6;
        optional bytes merchant_data = 7;
    }

PaymentDetails中指定的payment_url应至少保持有效，直到PaymentDetails过期（或者如果PaymentDetails没有过期，则尽可能长）。 请注意，这与基础支付请求中的任何状态更改无关; 例如取消订单不应该使payment_url无效，因为重要的是商家的服务器可以记录错误付款以便退还付款。

PaymentRequest是PaymentDetails（可选）绑定到商人的身份：

    message PaymentRequest {
        optional uint32 payment_details_version = 1 [default = 1];
        optional string pki_type = 2 [default = "none"];
        optional bytes pki_data = 3;
        required bytes serialized_payment_details = 4;
        optional bytes signature = 5;
    }

当比特币钱包应用程序收到PaymentRequest时，它必须通过执行以下操作来授权付款：

1. 如果pki_type不是“none”，则使用PKI系统验证商家的身份和签名。
2. 验证客户的系统unix时间（UTC）在PaymentDetails.expires之前。 如果不是，则支付请求必须被拒绝。
3. 显示商户的身份，询问客户是否要提交付款（例如在第一个X.509证书中显示“通用名称”）。

大于50,000字节的PaymentRequest消息应该被钱包应用拒绝，以减轻拒绝服务攻击。

Payment

付款消息在客户授权付款后发送：

    message Payment {
        optional bytes merchant_data = 1;
        repeated bytes transactions = 2;
        repeated Output refund_to = 3;
        optional string memo = 4;
    }

如果客户授权付款，那么比特币客户端：

1. 创建并签署一个或多个符合（支付全额）PaymentDetails.outputs的交易
2. 验证客户的系统unix时间（UTC）仍然在PaymentDetails.expires之前。 如果不是，应该取消付款。
3. 在比特币P2P网络上广播交易
4. 如果指定了PaymentDetails.payment_url，则将支付消息发送到该URL。 付款消息被序列化并作为POST请求的主体发送。

与payment_url服务器通信的错误应该传达给用户。 在商户的服务器接收到多个相同的支付消息的个人PaymentRequest的情况下，它必须承认每个。 从商家的服务器发送的第二个和另外的PaymentACK消息可以根据备注字段而变化以指示支付的当前状态（例如在网络上看到的确认的数量）。 这是必需的，以确保在传输过程中传输级别失败的情况下，比特币客户端可以通过重新发送付款消息来进行恢复。

PaymentDetails.payment_url应该是安全的，以防止可能改变Payment.refund_to的中间人攻击（如果使用HTTP，它必须是TLS保护的）。

通过HTTP发送付款消息的电子钱包软件必须设置适当的Content-Type和Accept头，如BIP 71中所述：

Content-Type: application/bitcoin-payment
Accept: application/bitcoin-paymentack

当商家的服务器收到付款消息时，必须确定交易是否满足付款条件。 当且仅当他们这样做，它应该在比特币p2p网络上广播交易。

大于50,000字节的支付消息应该被商家的服务器拒绝，以减轻拒绝服务攻击。

PaymentACK

PaymentACK是支付协议中的最终消息。 它是从商家的服务器发送到比特币钱包以响应支付消息：

    message PaymentACK {
        required Payment payment = 1;
        optional string memo = 2;
    }

大于60,000字节的PaymentACK消息应该被钱包应用拒绝，以减轻拒绝服务攻击。 这大于支付和PaymentRequest消息的限制，因为PaymentACK包含完整的支付消息。

本地化

支持多种语言的商家应该生成特定于语言的PaymentRequests，并将该语言与请求相关联，或者在请求的merchant_data中嵌入语言标签。 他们还应根据原始请求生成特定于语言的PaymentACK。

例如：希腊语客户浏览希腊语版本的商人网站时，会点击一个“Αγοράτώρα”链接，该链接会生成一个Paymentntquest，其中merchant_data设置为“lang = el＆basketId = 11252”。 客户支付，他们的比特币客户端发送支付信息，而商家的网站用PaymentACK.message回答“σαςευχαριστούμε”。

证书

默认的PKI系统是X.509证书（与用于验证Web服务器的系统相同）。 当pki_type是“x509 + sha256”或“x509 + sha1”时，pki_data的格式是协议缓冲器编码的证书链：

    message X509Certificates {
        repeated bytes certificate = 1;
    }

如果pki_type是“x509 + sha256”，则使用SHA256算法对PaymentRequest消息进行散列，以产生经过签名的消息摘要。 如果pki_type是“x509 + sha1”，则使用SHA1算法。

每个证书都是DER [ITU.X690.1994] PKIX证书值。 包含数字签名PaymentRequest的实体的公钥的证书必须是第一个证书。 这必须附加额外的证书，每个后续证书是用于证明前一个证书的证书，直到（但不包括）受信任的根权威机构。 受信任的根权限可以包括在内。 收件人必须根据[RFC5280]验证证书链，如果发生验证失败，则拒绝PaymentRequest。

受信任的根证书可以从操作系统获得; 如果在没有操作系统的设备上进行验证，则推荐使用Mozilla根存储。

可扩展性

协议缓冲区序列化格式被设计为可扩展的。 特别是，可以将新的可选字段添加到消息中，并且将被旧的实现忽略（但是保存/重新传输）。

PaymentDetails消息可以用新的可选字段进行扩展，仍然被认为是“版本1”。 旧的实现将能够验证包含新字段的PaymentRequests的签名，但是（显然）将无法显示新的可选字段中包含的任何信息给用户。

如果商家在未来的某个时候有必要生成PaymentRequest消息，而这些消息只能被新的实现所接受，那么他们可以通过定义一个version = 2的新的PaymentDetails消息来实现。 旧的实现应该让用户知道他们需要升级他们的软件，当他们得到一个上传版本PaymentDetails消息。

在本规范中需要扩展消息的实现应使用从1000开始的标签，并通过pull-req更新扩展页面以避免与其他扩展冲突。

参考

BIP 0071：支付协议MIME类型

BIP 0072：支付协议比特币：URI扩展

公钥基础设施（X.509）工作组：http://datatracker.ietf.org/wg/pkix/charter/

协议缓冲区：https://developers.google.com/protocol-buffers/

参考实现

创建付款请求生成器：https://bitcoincore.org/~gavin/createpaymentrequest.php（源）

BitcoinJ https://bitcoinj.github.io/payment-protocol#introduction

另见附注

Javascript对象签名和加密工作组：http://datatracker.ietf.org/wg/jose/

维基百科的发票页面：http://en.wikipedia.org/wiki/Invoice特别是电子发票标准清单

sipa的付款协议建议：https://gist.github.com/1237788

ThomasV的“签名别名”提案：http://ecdsa.org/bitcoin_URIs.html

同态付款地址和付款合同协议：http://arxiv.org/abs/1212.3257

参考资料

• https://github.com/bitcoin/bips/blob/d2a8fb089d7010d839530f879e07edc4e48b84fa/bip-0070/paymentrequest.proto
• https://github.com/bitcoin/bips/blob/d2a8fb089d7010d839530f879e07edc4e48b84fa/bip-0070/extensions.mediawiki
• https://github.com/bitcoin/bips/blob/d2a8fb089d7010d839530f879e07edc4e48b84fa/bip-0071.mediawiki
• https://github.com/bitcoin/bips/blob/d2a8fb089d7010d839530f879e07edc4e48b84fa/bip-0072.mediawiki
• https://developers.google.com/protocol-buffers/
• https://bitcoinj.github.io/payment-protocol#introduction

#include <netdb.h>

const char *hstrerror(int err);  //h_errno

struct hostent
{
char  *h_name;       //地址的正式名称
char **h_aliases;    //地址的预备名称的指针
int    h_addrtype;   //地址类型
int    h_length;     //地址的比特长度
char **h_addr_list;  //主机网络地址指针,网络字节顺序
};
struct hostent *gethostbyname(const char *hostname);
struct hostent *gethostbyname_r(const char *hostname, struct hostent *result, char *buf, int buflen/*8192*/, int *h_errnop);
struct hostent *gethostbyaddr(const char *addr, socklen_t len, int family);
struct hostent *gethostbyaddr_r(const char *addr, int len, int type, struct hostent *result, char* buf, int buflen/*8192*/, int* h_errnop);

struct servent 
{
char  *s_name;     //正规的服务名
char **s_aliases;  //一个以空指针结尾的可选服务名队列
int    s_port;     //连接该服务时需要用到的端口号，返回的端口号是以网络字节顺序排列的
char  *s_proto;    //连接该服务时用到的协议名
};
struct servent* getservbyname(const char *servname, const char *protoname);
struct servent* getservbyport(int port, const char* protoname);

struct addrinfo 
{
    int ai_flags;      /*in*/
    int ai_family;     /*in*/
    int ai_socktype;   /*in*/
    int ai_protocol;   /*in*/ /*IPPROTO_TCP/IPPROTO_UDP*/
    socklen_t ai_addrlen;
    struct sockaddr *ai_addr;
    char *ai_canonname;
    struct addrinfo *ai_next;
};
int getaddrinfo(const char *hostname, const char *service, const struct addrinfo *hints, struct addrinfo **result);
const char* gai_strerror(int error);     //getaddrinfo的返回值做参数
void freeaddrinfo(struct addrinfo* ai);  //形参是链表头
int getnameinfo(const struct sockaddr* sockaddr, socklen_t addrlen, char* host, socklen_t hostlen, char* serv, socklen_t servlen, int flags);

前端基础-html标签

先来看一个Html模板

<!DOCTYPE html><!--文档类型-->
<html lang="en"><!--根标签-->
<head><!--网页头部-->
    <meta charset="UTF-8">  <!--编码格式-->
    <title>HTML模板</title>
</head>
<body><!--可视化区域  网页主体-->

</body>
</html>

HTML命名规范

HTML书写规范：
1.名字用小写字母
2.以英文开头，可以包含英文字符、数字、_、-，不能使用中文
3.驼峰命名
4.id命名：id只能有一个名字，而且在页面中相同的名字只能出现一次，相当于身份证号码
5.class命名：class可以出现多次

Html常用标签学习

# 1. h1-h6标题标签
<h1>我是H1标签</h1> <!--一般H1标签只会有一个，有利于搜索-->
<h2>我是H2标签</h2>
<h3>我是H3标签</h3>
<h4>我是H4标签</h4>
<h5>我是H5标签</h5>
<h6>我是H6标签</h6>

#2.p标签，段落标签
<p>Python 的创始人</p>

#3.strong标签，加粗标签
<strong id="box">我是strong加粗的标签</strong> <!--不仅能加粗，还有力搜索引擎搜索-->

#4.b标签，加粗标签
<b>我是b标签加粗</b><!--只是物理加粗-->

#5.em标签，斜体标签
<em>我是斜体的</em><!--强调斜体，还有力搜索引擎搜索-->

#6.i标签，斜体标签
<i>我是斜体i标签</i><!--斜体作用-->
换行标签
#7.br标签，换行标签
<br/>

#8.hr标签，水平线标签
<hr/>

#9.特殊符号
<p>
    小于号： &lt; <br/>
    大于号：&gt; <br/>
    空格符号：12&nbsp;34<br/>
    空白位：12&emsp;&emsp;&emsp;&emsp;34<br/>
    &字符:&amp;<br/>
    版权符号:&copy;<br/>
</p>

#10.a标签
<a href="http://www.baidu.com">百度</a> <br/>  <!--超链接-->
<a href="#">#刷新当前页面</a> <br/> <!--刷新页面-->
<a href="javascript:void (0)">死链接</a><br/><!--死链接-->
<a href="#box">锚点</a> <br/>

<!--
    只有a标签才有name属性
    其他标签要使用锚点，需要通过id属性跳转
-->
#锚点跳转的页面，name属性
<a href="javascript:void (0)" name="box">我是最前面的a标签</a>

#11.img标签
<img src="https://ss1.bdstatic.com/70cFvXSh_Q1YnxGkpoWK1HF6hhy/it/u=594559231,2167829292&fm=27&gp=0.jpg"
     alt="百度图片"
     width="100" height="100">
<!--
src 图片的路径
alt 图片的描述
width 宽度
height 高度
-->

Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.

For example,
Given:
s1 = “aabcc”,
s2 = “dbbca”,

When s3 = “aadbbcbcac”, return true.
When s3 = “aadbbbaccc”, return false.

思路：动态规划。
这种字符串交错组合的题目是典型的dp问题，状态dp[l1][l2]表示长度l1的s1和长度l2的s2能否通过交错组合找到s3，初始化状态dp[0][0],dp[0][i],dp[i][0]后，状态方程为dp[i][j]=(dp[i-1][j]&&s1[i-1]==s3[i+j-1])||(dp[i][j-1]&&s2[j-1]==s3[i+j-1]).

class Solution {
public:
    bool isInterleave(string s1, string s2, string s3) {
        int l1=s1.size(),l2=s2.size(),l3=s3.size();
        if(l1+l2!=l3) return false;
        bool dp[l1+1][l2+1];
        dp[0][0]=true;
        for(int i=1;i<=l1;i++){
            dp[i][0]=(s1[i-1]==s3[i-1]&&dp[i-1][0]);
        }
        for(int i=1;i<=l2;i++){
            dp[0][i]=(s2[i-1]==s3[i-1]&&dp[0][i-1]);
        }
        for(int i=1;i<=l1;i++){
            for(int j=1;j<=l2;j++){
                dp[i][j]=(dp[i-1][j]&&s1[i-1]==s3[i+j-1])||(dp[i][j-1]&&s2[j-1]==s3[i+j-1]);
            }
        }
        return dp[l1][l2];
    }
};

package com.algorithm.sort;

public class HeapSortInPlace {
    private HeapSortInPlace() {
    }

    public static void sort(Integer[] arr) {
        int n = arr.length;

        // 注意：我们堆的索引是从0开始的
        // 从（最后一个元素的索引-1）/2 开始
        // 最后一个元素的索引为 n-1

        // 将数组原地 shiftDown 变为 最大堆
        for (int i = (n - 1 - 1) / 2; i >= 0; i--) {
            shiftDown(arr, n, i);
        }
        // 交换数组的第一个元素（最大元素）与数组末尾的元素（i）
        // 使整个数组从后向前依次有序
        // 对剩余的数组进行 shiftDown 操作，使其变为 最大堆
        for (int i = n - 1; i > 0; i--) {
            SortTestHelper.swap(arr, 0, i);
            shiftDown(arr, i, 0);
        }
    }

    private static void shiftDown(Integer[] arr, int n, int k) {
        // 当存在 左子节点 时
        while (2 * k + 1 < n) {

            // j 为 左子节点
            int j = 2 * k + 1;

            // 右子节点（j+1）存在，且 右子节点 > 左子节点
            if (j + 1 < n && arr[j + 1].compareTo(arr[j]) > 0) {
                // j 移动到 右子节点处
                j++;
            }

            // 父节点（k） > 子节点中较大者, break
            if (arr[k].compareTo(arr[j]) >= 0) break;

            // 父节点（k） 与 子节点中较大者进行交换
            SortTestHelper.swap(arr, j, k);

            // k 移动到 子节点中 较大者 的位置（j）
            k = j;
        }
    }

    public static void main(String[] args) {
        int N = 100000;
        Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);

        System.out.println("排序前的数组为：");
        SortTestHelper.printArray(arr);
        Long start = System.currentTimeMillis();
        HeapSortInPlace.sort(arr);
        Long end = System.currentTimeMillis();
        System.out.println("-------------------------------------------");

        System.out.println("排序后的数组为：");
        SortTestHelper.printArray(arr);
        System.out.println("-------------------------------------------");

        System.out.println("排序后的数组是否有序：");
        if (SortTestHelper.isSorted(arr)) {
            System.out.println("数组有序~");
        } else {
            System.out.println("数组无序！");
        }
        System.out.println("-------------------------------------------");

        System.out.println("排序算法的运行时间为" + " : " + (end - start) + "ms");
    }

}

1.

package com.vadonmo.exp.chapter;

/**
 * 为FixedCapacityStackOfStrings添加一个isFull()
 * 
 * @author vadon
 *
 */
public class Exp1_3_1 {

    public class FixedCapacityStackOfStrings {
        private String[] a;
        private int N;

        public FixedCapacityStackOfStrings(int cap) {
            a = new String[cap];
        }

        public boolean isEmpty() {
            return N == 0;
        }

        /**
         * 是否满
         * 
         * @return
         * @return boolean
         */
        public boolean isFull() {
            return a.length > N;
        }

        public int size() {
            return N;
        }

        public void push(String item) {
            a[N++] = item;
        }

        public String pop() {
            return a[--N];
        }
    }
}

2.

package com.vadonmo.exp.chapter;

import com.vadonmo.exp.api.StdIn;
import com.vadonmo.exp.api.StdOut;
import com.vadonmo.exp.example.Stack;

/**
 * 给定一下输入，java Stack的输出是什么 
 * it was - the best - of times - - - it was - the - -
 * 
 * @author vadon
 *
 */
public class Exp1_3_2 {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<String>();
        while (!StdIn.isEmpty()) {
            String item = StdIn.readString();
            if (!item.equals("-")) {
                stack.push(item);
            } else if (!stack.isEmpty()) {
                StdOut.print(stack.pop() + " ");
            }
        }
        StdOut.println("(" + stack.size() + " left on stack)");

    }
    // was best times of the was the it (1 left on stack)
}

3.

package com.vadonmo.exp.chapter;

/**
 * 假设某个用例程序会进行过一系列入栈和出栈的混合栈操作。
 * 入栈操作会将整数0-9按顺序压入栈；出栈操作会打印出返回值。
 * 下面哪种序列是不可能产生的？
 * a. 4 3 2 1 0 9 8 7 6 5
 * b. 4 6 8 7 5 3 2 9 0 1
 * c. 2 5 6 7 4 8 9 3 1 0
 * d. 4 3 2 1 0 5 6 7 8 9
 * e. 1 2 3 4 5 6 9 8 7 0
 * f. 0 4 6 5 3 8 1 7 2 9
 * g. 1 4 7 9 8 6 5 3 0 2
 * h. 2 1 4 3 6 5 8 7 9 0
 * 
 * @author vadon
 *
 */
public class Exp1_3_3 {
    /*
     * a. 4 3 2 1 0 9 8 7 6 5 T
     * b. 4 6 8 7 5 3 2 9 0 1 F
     * c. 2 5 6 7 4 8 9 3 1 0 T
     * d. 4 3 2 1 0 5 6 7 8 9 T
     * e. 1 2 3 4 5 6 9 8 7 0 T
     * f. 0 4 6 5 3 8 1 7 2 9 F
     * g. 1 4 7 9 8 6 5 3 0 2 F
     * h. 2 1 4 3 6 5 8 7 9 0 T
     */
}

4.

package com.vadonmo.exp.chapter;

import com.vadonmo.exp.api.StdIn;
import com.vadonmo.exp.api.StdOut;
import com.vadonmo.exp.example.Stack;

/**
 * 编写一个Stack用例Parenthess，从标准输入中读取一个文本流并使用栈判定其中的括号是否匹配完整。
 * 
 * @author vadon
 *
 */
public class Exp1_3_4 {

    public static void main(String[] args) {
        Parenthess();
    }

    public static void Parenthess() {
        Stack<String> stack = new Stack<String>();
        String string = StdIn.readString();
        String[] items = string.trim().split("");
        for (String item : items) {
            if (item.equals("[") || item.equals("(") || item.equals("{")) {
                stack.push(item);
            } else if (!stack.isEmpty()) {
                if (item.equals("}")) {
                    if (!stack.pop().equals("{")) {
                        StdOut.println(false);
                        return;
                    }
                } else if (item.equals("]")) {
                    if (!stack.pop().equals("[")) {
                        StdOut.println(false);
                        return;
                    }
                } else if (item.equals(")")) {
                    if (!stack.pop().equals("(")) {
                        StdOut.println(false);
                        return;
                    }
                }
            }
        }
    }
    // [()]{}{[()()]()} True
    // [(]) False
}

5.

package com.vadonmo.exp.chapter;

import com.vadonmo.exp.api.StdOut;
import com.vadonmo.exp.example.Stack;

/**
 * 当N为50时下面这段代码会打印什么？从较高的抽象层次描述给定正整数N时这段代码的行为
 * 
 * @author vadon
 *
 */
public class Exp1_3_5 {

    public static void main(String[] args) {
        int N = 50;
        Stack<Integer> stack = new Stack<Integer>();
        while (N > 0) {
            stack.push(N % 2);
            N /= 2;
        }
        for (int d : stack)
            StdOut.print(d);
        StdOut.println();
    }
    // 110010 N的二进制
}

在 交互式解释器会话 中

在这种情况下，“_”代表交互式解释器会话中上一条执行的语句的结果。

>>> 10
10
>>> _
10
>>> 

作为 名称

此时“_”、“__”、“___”、“____”等等作为临时性的名称使用。这样，当其他人阅读你的代码时将会知道，你分配了一个特定的名称，但是并不会在后面再次用到该名称。

for _ in xrange(2):
    for __ in xrange(2):
        for ___ in xrange(2):
            print _, __, ___

打印结果：

0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1

在 函数名 or 变量名 前后

名称前的单下划线

私有，private，仅供内部使用。

如 _loss 。

名称后的单下划线

用于和 Python 关键词区分开来。

如 list_ 。

名称前的双下划线

用于避免与子类定义的名称冲突。

名称两侧的双下划线

表示非用户自定义的名称。可以被直接引用。

如 __init__ 。

Ref:

• 详解Python中的下划线
• 【python】下划线

   几个Java 8的例子展示怎样将一个 对象的集合（List）放入一个Map中，并且展示怎样处理多个重复keys的问题。

package com.mkyong.java8

public class Hosting {

    private int Id;
    private String name;
    private long websites;

    public Hosting(int id, String name, long websites) {
        Id = id;
        this.name = name;
        this.websites = websites;
    }

    //getters, setters and toString()
}

1. List to Map – Collectors.toMap()

创建一个 Hosting 对象集合, 并且用 Collectors.toMap 去将它转换放入一个 Map.

package com.mkyong.java8

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class TestListMap {

    public static void main(String[] args) {

        List<Hosting> list = new ArrayList<>();
        list.add(new Hosting(1, "liquidweb.com", 80000));
        list.add(new Hosting(2, "linode.com", 90000));
        list.add(new Hosting(3, "digitalocean.com", 120000));
        list.add(new Hosting(4, "aws.amazon.com", 200000));
        list.add(new Hosting(5, "mkyong.com", 1));

        // key = id, value - websites
        Map<Integer, String> result1 = list.stream().collect(
                Collectors.toMap(Hosting::getId, Hosting::getName));

        System.out.println("Result 1 : " + result1);

        // key = name, value - websites
        Map<String, Long> result2 = list.stream().collect(
                Collectors.toMap(Hosting::getName, Hosting::getWebsites));

        System.out.println("Result 2 : " + result2);

        // Same with result1, just different syntax
        // key = id, value = name
        Map<Integer, String> result3 = list.stream().collect(
                Collectors.toMap(x -> x.getId(), x -> x.getName()));

        System.out.println("Result 3 : " + result3);
    }
}

Output

Result 1 : {1=liquidweb.com, 2=linode.com, 3=digitalocean.com, 4=aws.amazon.com, 5=mkyong.com}
Result 2 : {liquidweb.com=80000, mkyong.com=1, digitalocean.com=120000, aws.amazon.com=200000, linode.com=90000}
Result 3 : {1=liquidweb.com, 2=linode.com, 3=digitalocean.com, 4=aws.amazon.com, 5=mkyong.com}

2. List to Map – Duplicated Key! （List转Map 重复key问题）

2.1 Run below code, and duplicated key errors will be thrown!

package com.mkyong.java8;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class TestDuplicatedKey {

    public static void main(String[] args) {

        List<Hosting> list = new ArrayList<>();
        list.add(new Hosting(1, "liquidweb.com", 80000));
        list.add(new Hosting(2, "linode.com", 90000));
        list.add(new Hosting(3, "digitalocean.com", 120000));
        list.add(new Hosting(4, "aws.amazon.com", 200000));
        list.add(new Hosting(5, "mkyong.com", 1));

        list.add(new Hosting(6, "linode.com", 100000)); // new line

        // key = name, value - websites , but the key 'linode' is duplicated!?
        Map<String, Long> result1 = list.stream().collect(
                Collectors.toMap(Hosting::getName, Hosting::getWebsites));

        System.out.println("Result 1 : " + result1);

    }
}

输出：下面这个错误有的误导，它应该显示 “linode” 代替key的值。

Exception in thread "main" java.lang.IllegalStateException: Duplicate key 90000
	at java.util.stream.Collectors.lambda$throwingMerger$0(Collectors.java:133)
	at java.util.HashMap.merge(HashMap.java:1245)
	//...

2.2  为了解决上面重复key的问题，通过增加第三个参数解决:

Map<String, Long> result1 = list.stream().collect(
                Collectors.toMap(Hosting::getName, Hosting::getWebsites,
                        (oldValue, newValue) -> oldValue
                )
        );

Output

Result 1 : {..., aws.amazon.com=200000, linode.com=90000}

3.3 Try newValue

Map<String, Long> result1 = list.stream().collect(
                Collectors.toMap(Hosting::getName, Hosting::getWebsites,
                        (oldValue, newValue) -> newvalue
                )
        );

Output

Result 1 : {..., aws.amazon.com=200000, linode.com=100000}

3. List to Map – Sort & Collect

package com.mkyong.java8;

import java.util.*;
import java.util.stream.Collectors;

public class TestSortCollect {

    public static void main(String[] args) {

        List<Hosting> list = new ArrayList<>();
        list.add(new Hosting(1, "liquidweb.com", 80000));
        list.add(new Hosting(2, "linode.com", 90000));
        list.add(new Hosting(3, "digitalocean.com", 120000));
        list.add(new Hosting(4, "aws.amazon.com", 200000));
        list.add(new Hosting(5, "mkyong.com", 1));
        list.add(new Hosting(6, "linode.com", 100000));

        //example 1
        Map result1 = list.stream()
                .sorted(Comparator.comparingLong(Hosting::getWebsites).reversed())
                .collect(
                        Collectors.toMap(
                                Hosting::getName, Hosting::getWebsites, // key = name, value = websites
                                (oldValue, newValue) -> oldValue,       // if same key, take the old key
                                LinkedHashMap::new                      // returns a LinkedHashMap, keep order
                        ));

        System.out.println("Result 1 : " + result1);

    }
}

Output

Result 1 : {aws.amazon.com=200000, digitalocean.com=120000, linode.com=100000, liquidweb.com=80000, mkyong.com=1}

P.S  在上面的例子中， stream 在collect 之前已经被排序, 所以 “linode.com=100000”变为 ‘oldValue’.

References

1. Java 8 Collectors JavaDoc
2. Java 8 – How to sort a Map
3. Java 8 Lambda : Comparator example

进程

　　系统中程序执行和资源分配的基本单位

　　每个进程有自己的数据段、代码段和堆栈段

　　在进行切换时需要有比较复杂的上下文切换

线程

　　减少处理机的空转时间，支持多处理器以及减少上下文切换开销, 比创建进程小很多

　　进程内独立的一条运行路线

　　处理器调度的最小单元，也称为轻量级进程

       可以对进程的内存空间和资源进行访问，并与同一进程中的其他线程共享

线程

　　线程相关的执行状态和存储变量放在线程控制表内

　　一个进程可以有多个线程，有多个线程控制表及堆栈寄存器，共享一个用户地址空间

多线程同步问题

　　线程共享进程的资源和地址空间

　　任何线程对系统资源的操作都会给其他线程带来影响

一．线程标识

　　线程ID

•进程ID在整个系统中是唯一的

•线程ID只在它所属的进程环境中有效

       函数: pthread_self()

线程标识

pthread_t类型通常用结构来表示

•不能把它作为整数处理

–Linux使用无符号长整数表示

•为了移植，使用函数来比较线程ID

函数: pthread_equal()

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
int main(){
   pthread_t thread_id;
 
   thread_id=pthread_self(); // 返回调用线程的线程ID
   printf("Thread ID: %lu.\n",thread_id);
 
   if (pthread_equal(thread_id,pthread_self())) {
//   if (thread_id==0) {
       printf("Equal!\n");
    }else {
       printf("Not equal!\n");
    }
   return 0;
}

二．创建线程

•调用该线程函数的入口点

•使用函数pthread_create()，线程创建后，就开始运行相关的线程函数

例子

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *run(void *data)
{
       printf("我是线程\n");
}
 
int main()
{
       pthread_ttid;
       char*re;
       pthread_create(&tid,NULL,run,NULL);
}

执行结果，什么都没有输出，为什么呢？事实上我们已经创建了，但是因为主线程退出，导致整个程序退出，所以导致“我是线程”没有打印出来

解决方法可以在pthread_create后加sleep，这种方法可以解决，但是在正常程序中并不会采用这种方法，通常采用pthread_join，进入下一个主题来介绍pthread_join

三．线程取消

单个线程可以通过三种方法取消

1）  线程主动return

2）  线程主动调用pthread_exit()

3）  被其他线程cancel

第一种方法不说明，看字面意思就知道

第二种方法说明

使调用进程终止，所有线程都终止了

等待线程

•由于一个进程中的多个线程是共享数据段的，通常在线程退出之后，退出线程所占用的资源并不会随着线程的终止而得到释放

•pthread_join()函数

　　　　类似进程的wait()/waitpid()函数，用于将当前线程挂起来等待线程的结束

　　　　是一个线程阻塞的函数，调用它的线程一直等待到被等待的线程结束为止

　　　　函数返回时，被等待线程的资源就被收回

继续上面那个线程创建的例子，没有打印的例子，并且增加退出码的打印

修改成以下模样

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
 
void *run(void *data)
{
       printf("我是线程 %s\n",(char*)data);
       //return"hello";
       pthread_exit("world");
}
 
int main()
{
       pthread_ttid;
       char*re;
       pthread_create(&tid,NULL,run,(void*)"zhongjun");
       pthread_join(tid,(void**)&re);
       printf("%s\n",re);
}

输出结果

我们发现我们创建的线程打印出来，并且有返回码

第三种pthread_cancel取消线程

这个用起来考虑的点就比较多了

1）  并不是调用pthread_cancel就能100%把线程cancel掉的，但是有一些系统函数自带一些cancel点，此部分可以去网络查找

2）  线程中是否有互斥量（后面说），可以理解为锁，如果cancel线程的时候正在加锁和解锁之间，那么就会造成死锁问题

先来看看第一种情况

#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
void *run(void *data)
{
       while(1)
       {
       }
}
 
int main()
{
       pthread_ttid;
       char*re;
       pthread_create(&tid,NULL,run,NULL);
       
       sleep(5);
       printf("开始cancel线程\n");
       pthread_cancel(tid);
       pthread_join(tid,(void**)0);
}

程序一直在运行，外部调用pthread_cancel线程并不是被cancel掉

解决办法

1）  在函数中加打印（打印的fput有cancel点）

发现程序运行结果为

2）  延时

3）  最正宗的方法是在要被cancel的线程中加pthread_testcancel()函数

运行结果

上面还遗留一个pthread_cancel在互斥量加锁和解锁中造成死锁的问题

先来看看互斥量的概念

编程模型：

1）定义互斥量pthread_mutex_t

2）初始化互斥量 1pthread_mutex_init

3）互斥量操作      置0phtread_mutex_lock

                            判定互斥量0：阻塞

                            1：置0，返回

                 置1pthread_mutex_unlock

                            置1返回

                            强烈要求成对使用                                           

4）释放互斥量pthread_mutex_destroy

模拟一个pthread_cancel在互斥量加锁和解锁中造成死锁的问题

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
 
pthread_mutex_t mutex;
 
void *runodd(void *data)
{
       inti=0;
       
       for(i=1;;i=i+2)
       {
              pthread_mutex_lock(&mutex);
              printf("%d\n",i);
              
              pthread_mutex_unlock(&mutex);
       }
}
 
void *runeven(void *data)
{
       inti=0;
       for(i=0;;i=i+2)
       {
              pthread_mutex_lock(&mutex);
              printf("%d\n",i);
              pthread_mutex_unlock(&mutex);
       }
}
 
int main()
{
       pthread_ttodd,teven;
       
       pthread_mutex_init(&mutex,0);
       pthread_create(&todd,NULL,runodd,NULL);
       pthread_create(&teven,NULL,runeven,NULL);
       
       sleep(5);
       pthread_cancel(todd);
       pthread_join(todd,(void**)0);
       pthread_join(teven,(void**)0);
       pthread_mutex_destroy(&mutex);
       
}

两个程序，一个打印基数，一个打印偶数，在5s后外部cancel掉打印基数的线程，由于基数线程在程序中的只有一个cancel掉，就是printf，所以很大的可能是在那被cancel掉，导致死锁问题，程序运行如我们预期的那样

程序运行了5s，不再输出

解决方法：pthread_cleanup_pushpthread_cleanup_pop

这个类似于进程退出的atexit函数，也是在线程退出时调用，但是有几个需要注意的点是：

1）  这两个函数表面看着是函数，但是实际是宏，必须成对使用，否则编译出错

2）  pthread_cleanup_push是压栈行为，把函数注册到线程退出时调用，再满足以下几个条件回调函数才能被调用，线程pthread_exit退出,线程被外部cancel

3）  pthread_cleanup_pop此函数有参数，0代表弹出栈，代表回调函数不再起作用

1代表主动调用回调函数

四．线程同步

线程同步有以下几种方法

1）  互斥量

2）  信号量

3）  条件量

4）  读写锁

5）  屏障

6）  信号

分别介绍下，4,5,6我用的比较少，暂时不介绍

1.  互斥量

互斥量上面已做简单介绍，在来介绍下

参考：https://www.cnblogs.com/yuuyuu/p/5140251.html

互斥量是线程同步的一种机制，用来保护多线程的共享资源。同一时刻，只允许一个线程对临界区进行访问。

互斥量的工作流程：创建一个互斥量，把这个互斥量的加锁调用放在临界区的开始位置，解锁调用放到临界区的结束位置。当内核优先把某个线程调度到临界区的开始位置时，线程执行这个加锁调用，并进入临界区对资源进行操作。此时其他线程再被内核调度到这里的时候，由于该互斥量已被加锁状态，得不到锁会一直阻塞在这里，导致其他线程不能进入临界区，直到刚刚那个进入临界区的线程离开临界区并执行解锁调用。

函数接口                                         

1）.初始化互斥量

互斥量是一个pthread_mutex_t类型的变量。

1.1：用宏常量初始化：

1 pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;

1.2：用函数初始化：

 #include <pthread.h>

 int pthread_mutex_init(pthread_mutex_t*restrict mutex, const pthread_mutexattr_t *restrict attr);

mutex：互斥量结构指针

attr：互斥量的属性结构指针

2）.设置互斥量属性

 #include <pthread.h>

 intpthread_mutexattr_settype(pthread_mutexattr_t *attr, int type);

attr：互斥量的属性结构指针

type：PTHREAD_MUTEX_NORMAL(默认属性)，PTHREAD_MUTEX_ERRORCHECK(会进行错误检查，速度比较慢)，PTHREAD_MUTEX_RECURSIVE(递归锁)。对于递归锁，同一个线程对一个递归锁加锁多次，会有一个锁计数器，解锁的时候也需要解锁这个次数才能释放该互斥量。

3）.加锁与解锁

#include <pthread.h>

int pthread_mutex_lock(pthread_mutex_t *mutex);

int pthread_mutex_trylock(pthread_mutex_t *mutex);

int pthread_mutex_unlock(pthread_mutex_t *mutex);

参数都是互斥量指针。pthread_mutex_lock()得不到锁会阻塞，intpthread_mutex_trylock()得不到锁会立即返回，并返回EBUSY错误。

还有一个pthread_mutex_timedlock()会根据时间来等待加锁，如果这段时间得不到锁会返回ETIMEDOUT错误！

#include <pthread.h>

#include <time.h>

int pthread_mutex_timedlock(pthread_mutex_t *restrict mutex, const structtimespec *restrict abs_timeout);

4）.销毁互斥量

#include <pthread.h>

int pthread_mutex_destroy(pthread_mutex_t *mutex);

mutex：创建的互斥量指针

2.  条件量

参考：https://www.cnblogs.com/yuuyuu/p/5140875.html

1）.概述                                                 

上一篇，介绍了互斥量。条件变量与互斥量不同，互斥量是防止多线程同时访问共享的互斥变量来保护临界区。条件变量是多线程间可以通过它来告知其他线程某个状态发生了改变，让等待在这个条件变量的线程继续执行。通俗一点来讲：设置一个条件变量让线程1等待在一个临界区的前面，当其他线程给这个变量执行通知操作时，线程1才会被唤醒，继续向下执行。

条件变量总是和互斥量一起使用，互斥量保护着条件变量，防止多个线程对条件变量产生竞争。等会写个小例子，看它们如何一起合作！

2）.函数接口                                          

初始化条件变量

宏常量初始化

pthread_cond_tcond = PTHREAD_COND_INITIALIZER;

函数初始化

 #include <pthread.h>

 intpthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t*restrict attr);

跟互斥量类似，cond是条件变量的结构指针，attr是条件变量属性的结构指针。

等待和通知条件变量

 #include <pthread.h>

 intpthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrictmutex, const struct timespec *restrict abstime);

 int pthread_cond_wait(pthread_cond_t*restrict cond, pthread_mutex_t *restrict mutex);

 int pthread_cond_broadcast(pthread_cond_t *cond);

 intpthread_cond_signal(pthread_cond_t *cond);

等待函数里面，要传入一个互斥量。pthread_cond_timewait()可以指定一个时间来等待，如果规定的时间没有获得通知，就返回ETIMEDOUT错误。而pthread_cond_wait()会一直阻塞。

通知函数，pthread_cond_signal()至少唤醒一个等待的线程，pthread_cond_broadcast()会唤醒在该条件变量上所有线程。

销毁条件变量

 #include <pthread.h>

 int pthread_cond_destroy(pthread_cond_t *cond);

举一个例子

#include <stdio.h>
#include <pthread.h>
#include <signal.h>
pthread_t t1,t2;
pthread_cond_t cond;
pthread_mutex_t m;
void *r1(void *data)
{
               int s;
               while(1)
               {
                               pthread_cond_wait(&cond,&m);
                               printf("活动 \n");
               }
}
 
void *r2(void *data)
{
               while(1)
               {
                               sleep(1);
                               pthread_cond_signal(&cond);
 
               }
}
int main()
{
               pthread_mutex_init(&m,0);
               pthread_cond_init(&cond,0);
               pthread_create(&t1,NULL,r1,NULL);
               pthread_create(&t2,NULL,r2,NULL);
               
               pthread_join(t1,(void**)0);
               pthread_join(t2,(void**)0);
               
               pthread_cond_destroy(&cond);
               pthread_mutex_destroy(&m);   
}

运行效果

每隔1s中打印一次活动

但是此部分提出一个问题，为什么在信号量init的时候会有第二个互斥量的参数呢？

画一张图

如图两个线程，分别共享一个互斥量mutex1,假设线程1先运行，然后线程1加锁，等待信号，阻塞，等待线程2发送信号量，但是此时线程2发送mutex已经是lock状态，所以进不去，就会造成两个线程僵持状态，造成死锁问题，这就用到了pthread_cond_init第二个参数互斥量的作用

模拟一个出问题的程序

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
 
pthread_t t1,t2;
pthread_mutex_t m1,m2;
pthread_cond_t c;
 
void *r1(void *data)
{
               while(1)
               {
                               pthread_mutex_lock(&m1);
                               printf("接受信号量\n");
                               // 这就是mutex的作用，防止死锁
                               //pthread_cond_wait(&c,&m1);
                               pthread_cond_wait(&c,&m2);
                               pthread_mutex_unlock(&m1);
               }
}
 
void *r2(void *data)
{
               while(1)
               {
                               pthread_mutex_lock(&m1);
                               printf("发送信号量\n");
                               pthread_cond_signal(&c);
                               pthread_mutex_unlock(&m1);
               }
}
 
int main()
{
               pthread_cond_init(&c,0);
               pthread_mutex_init(&m1,0);
               pthread_mutex_init(&m2,0);
               
               pthread_create(&t1,NULL,r1,NULL);
               pthread_create(&t2,NULL,r2,NULL);
               
               pthread_join(t1,(void**)0);
               pthread_join(t2,(void**)0);
               
               pthread_mutex_destroy(&m2);
               pthread_mutex_destroy(&m1);
               pthread_cond_destroy(&c);
                               
}

程序运行会造成死锁问题

解决方法

修改此部分程序得到良好运行

3.  信号量

信号量的函数都以sem_开头，线程中使用的基本信号量函数有4个，它们都声明在头文件semaphore.h中。

sem_init函数

该函数用于创建信号量，其原型如下：

int sem_init(sem_t *sem, int pshared， unsigned int value);  

该函数初始化由sem指向的信号对象，设置它的共享选项，并给它一个初始的整数值。pshared控制信号量的类型，如果其值为0，就表示这个信号量是当前进程的局部信号量，否则信号量就可以在多个进程之间共享，value为sem的初始值。调用成功时返回0，失败返回-1.

sem_wait函数

该函数用于以原子操作的方式将信号量的值减1。原子操作就是，如果两个线程企图同时给一个信号量加1或减1，它们之间不会互相干扰。它的原型如下：

int sem_wait(sem_t *sem);  

sem指向的对象是由sem_init调用初始化的信号量。调用成功时返回0，失败返回-1.

sem_post函数

该函数用于以原子操作的方式将信号量的值加1。它的原型如下：

int sem_post(sem_t *sem);  

与sem_wait一样，sem指向的对象是由sem_init调用初始化的信号量。调用成功时返回0，失败返回-1.

sem_destroy函数

该函数用于对用完的信号量的清理。它的原型如下：

int sem_destroy(sem_t *sem);  

成功时返回0，失败时返回-1.

例子：

#include <stdio.h>
#include <pthread.h>
#include <semaphore.h>
 
sem_t sem;
void *run(void *data)
{
       while(1)
       {
              //3
              sem_wait(&sem);
              printf("解除阻塞\n");
       }
}
int main()
{
       pthread_ttid;
       //2
       sem_init(&sem,0,5);
       pthread_create(&tid,NULL,run,NULL);
       while(1)
       {
              sleep(1);
              sem_post(&sem);
       }
}

运行效果

五．线程属性

转载：http://blog.csdn.net/zsf8701/article/details/7843837

【题目】
考古发现某古墓石碑上刻着一个数字：13597，后研究发现：
这是一个素数！
并且，去掉首尾数字仍是素数！
并且，最中间的数字也是素数！
这样特征的数字还有哪些呢？通过以下程序的帮助可以轻松解决。
请仔细阅读代码，并填写划线部分缺失的代码。

【分析】
这是一道填空题目。
题目需要你填空的地方，仔细分析一下就是递归出口。
所以没有太多要分析的地方了。

【源码】

    static boolean isPrime(int n){
        if(n<=1) return false;
        for(int i=2; i*i<=n; i++){
            if(n%i==0) return false;
        }
        return true;
    }

    static void f(int[] x, int k){
        if(k==x.length-1){  // 填空位置
            if(isPrime(x[0]*10000 + x[1]*1000 + x[2]*100 + x[3]*10 + x[4]) &&
                isPrime(x[1]*100 + x[2]*10 + x[3]) &&
                isPrime(x[2]))
                System.out.println(""+x[0]+x[1]+x[2]+x[3]+x[4]);
            return;
        }

        for(int i=k; i<x.length; i++){
            {int tmp=x[k]; x[k]=x[i]; x[i]=tmp; }
            f(x,k+1);
            {int tmp=x[k]; x[k]=x[i]; x[i]=tmp; }
        }
    }

    static void test()
    {
        int[] x = {1,3,5,7,9};
        f(x,0);
    }

    public static void main(String[] args)
    {
        test();
    }

【结果】
13597
53791
79531
95713
91573

说明

Python标准库为我们提供了threading和multiprocessing模块编写相应的多线程/多进程代码。

从Python3.2开始，标准库为我们提供了concurrent.futures模块，concurrent.futures 模块的主要特色是 ThreadPoolExecutor 和
ProcessPoolExecutor 类，这两个类实现的接口能分别在不同的线程或进程中执行可调
用的对象。这两个类在内部维护着一个工作线程或进程池，以及要执行的任务队列。

Python 3.4 以后标准库中asyncio 包，这个包使用事件循环驱动的协程实现并发。这是 Python 中最大也
是最具雄心壮志的库之一。asyncio 大量使用 yield from 表达式，因此与
Python 旧版不兼容。

submit和map方法

submit方法作用是向线程池提交可回调的task，并返回一个回调实例。
example：

import time
from concurrent.futures import ThreadPoolExecutor


# 可回调的task
def pub_task(msg):
    time.sleep(3)
    return msg

# 创建一个线程池
pool = ThreadPoolExecutor(max_workers=3)

# 往线程池加入2个task
task1 = pool.submit(pub_task, 'a')
task2 = pool.submit(pub_task, 'b')

print(task1.done())        # False
time.sleep(4)
print(task2.done())        # True

print(task1.result())
print(task2.result())

map方法是创建一个迭代器，回调的结果有序放在迭代器中。

问题：

Executor.map 函数易于使用，不过有个特性可能有用，也可能没用，具体情况取决于需
求：这个函数返回结果的顺序与调用开始的顺序一致。如果第一个调用生成结果用时 10
秒，而其他调用只用 1 秒，代码会阻塞 10 秒，获取 map 方法返回的生成器产出的第一个
结果。在此之后，获取后续结果时不会阻塞，因为后续的调用已经结束。如果必须等到获
取所有结果后再处理，这种行为没问题；不过，通常更可取的方式是，不管提交的顺序，
只要有结果就获取。为此，要把 Executor.submit 方法和 futures.as_completed 函
数结合起来使用。

from concurrent.futures import ThreadPoolExecutor
import requests

URLS = ['http://www.csdn.com', 'http://qq.com', 'http://www.leasonlove.cn']


def task(url, timeout=10):
    return requests.get(url, timeout=timeout)

pool = ThreadPoolExecutor(max_workers=3)
results = pool.map(task, URLS)

for ret in results:
    print('%s, %s' % (ret.url, ret))

future异步编程

Future可以理解为一个在未来完成的操作，这是异步编程的基础。通常情况下，我们执行io操作，访问url时（如下）在等待结果返回之前会产生阻塞，cpu不能做其他事情，而Future的引入帮助我们在等待的这段时间可以完成其他的操作。

from concurrent.futures import ThreadPoolExecutor
from concurrent.futures import as_completed
import requests

URLS = ['http://www.csdn.cn', 'http://qq.com', 'http://www.leasonlove.cn']


def task(url, timeout=1):
    return requests.get(url, timeout=timeout)


with ThreadPoolExecutor(max_workers=3) as executor:
    future_tasks = [executor.submit(task, url) for url in URLS]

    for f in future_tasks:
        if f.running():
            print('%s is running' % str(f))

    for f in as_completed(future_tasks):
        try:
            ret = f.done()
            if ret:
                f_ret = f.result()
                print('%s, done, result: %s, %s' % (str(f), f_ret.url, f_ret.content))
        except Exception as e:
            # 第一个url无响应
            f.cancel()
            print(str(e))

asyncio库协程实现并发

对于gevent 和 asyncio

建议大家放弃Gevent，拥抱asyncio，asyncio是Python3.4以后标准库。而且由于Gevent直接修改标准库里面大部分的阻塞式系统调用，包括socket、ssl、threading和 select等模块，而变为协作式运行。但是我们无法保证你在复杂的生产环境中有哪些地方使用这些标准库会由于打了补丁而出现奇怪的问题。

import asyncio
import time
start = time.time()

async def do(x):
    print('Waiting: ', x)
    await asyncio.sleep(x)
    return 'Finish after {}s'.format(x)


task1 = do(1)
task2 = do(2)
task3 = do(4)

tasks = [
    asyncio.ensure_future(task1),
    asyncio.ensure_future(task2),
    asyncio.ensure_future(task3)
]

loop = asyncio.get_event_loop()
loop.run_until_complete(asyncio.wait(tasks))

for task in tasks:
    print('Task result: ', task.result())

end = time.time()
print('TIME: ', end - start)

协程与线程

如果使用线程做过重要的编程，你就知道写
出程序有多么困难，因为调度程序任何时候都能中断线程。必须记住保留锁，去保护程序
中的重要部分，防止多步操作在执行的过程中中断，防止数据处于无效状态。
而协程默认会做好全方位保护，以防止中断。我们必须显式产出才能让程序的余下部分运
行。对协程来说，无需保留锁，在多个线程之间同步操作，协程自身就会同步，因为在任
意时刻只有一个协程运行。想交出控制权时，可以使用 yield 或 yield from 把控制权
交还调度程序。这就是能够安全地取消协程的原因：按照定义，协程只能在暂停的 yield
处取消，因此可以处理 CancelledError 异常，执行清理操作。

参考资料：fluent Python

leason | blog

你应该定期更新 Homebrew

TL;DR

这篇文章是关于定期更新 Homebrew 的话题。它会告诉你定期更新的好处，常用的命令，以及用 brew pin 尽可能无痛地更新。

为什么要定期更新

我发现不少人都不会经常更新，或者只在必须用某个工具的新版本的时候才更新。他们的看法是，更新有可能产生一些意外的问题，反正当前环境足够稳定可以用，干嘛自找麻烦呢？

这个看法对也不对。对是因为，更新产生的潜在问题不可避免。不对是因为总有一天你需要升级的，也许是为了某个工具的新特性，也许是为了修复软件的漏洞，也许你安装的包非要依赖另一个包的新版本，等等。如果隔了很长一段时间才升级，那潜在的小问题可能就会变成大问题。

另一个有意思的现象是，当碰到比较破坏性的事情，比如 Mac OS 大版本更新后，很多人会选择重装 Homebrew 然后顺带安装最新版的包。很少人会去装一个指定的旧版本（除了特殊项目需要）。这说明他们不是不想用新版本，而是不想痛苦地更新。

既然总有一天需要更新，而更新带来问题不可避免，那为什么不更新得频繁点呢？这个道理跟 Git 的冲突解决有相似性。长时间不 pull/push 的代码更容易产生冲突，一个解决方法就是频繁地 commit & merge 。

我现在试着一个月更新一次，两次下来发现这些好处：

1. 每次更新的包很少，更新风险也小。
2. 更容易发现不需要的包，便于清理，不为不需要的东西买单。
3. 定期清理旧版本，释放空间。

更新流程其实都差不多，下面列一下我常用的命令。

更新包 (formula)

更新之前，我会用 brew outdated 查看哪些包可以更新。

brew outdated

然后就可以用 brew upgrade 去更新了。Homebrew 会安装新版本的包，但旧版本仍然会保留。

brew upgrade             # 更新所有的包
brew upgrade $FORMULA    # 更新指定的包

清理旧版本

一般情况下，新版本安装了，旧版本就不需要了。我会用 brew cleanup 清理旧版本和缓存文件。Homebrew 只会清除比当前安装的包更老的版本，所以不用担心有些包没更新但被删了。

brew cleanup             # 清理所有包的旧版本
brew cleanup $FORMULA    # 清理指定包的旧版本
brew cleanup -n          # 查看可清理的旧版本包，不执行实际操作

这样一套下来，该更新的都更新了，旧版本也被清理了。

锁定不想更新的包

如果经常更新的话，brew update 一次更新所有的包是非常方便的。但我们有时候会担心自动升级把一些不希望更新的包更新了。数据库就属于这一类，尤其是 PostgreSQL 跨 minor 版本升级都要迁移数据库的。我们更希望找个时间单独处理它。这时可用 brew pin 去锁定这个包，然后 brew update 就会略过它了。

brew pin $FORMULA      # 锁定某个包
brew unpin $FORMULA    # 取消锁定

其他几个常用命令

brew info 可以查看包的相关信息，最有用的应该是包依赖和相应的命令。比如 Nginx 会提醒你怎么加 launchctl ，PostgreSQL 会告诉你如何迁移数据库。这些信息会在包安装完成后自动显示，如果忘了的话可以用这个命令很方便地查看。

brew info $FORMULA    # 显示某个包的信息
brew info             # 显示安装了包数量，文件数量，和总占用空间

brew deps 可以显示包的依赖关系，我常用它来查看已安装的包的依赖，然后判断哪些包是可以安全删除的。

brew deps --installed --tree # 查看已安装的包的依赖，树形显示

输出如下：

elixir (required dependencies)
└── :erlang

wxmac (required dependencies)
├── jpeg
├── libpng
│   └── xz
└── libtiff
    └── jpeg

还有很多有用的命令和参数，没事 man brew 一下可以涨不少知识。

小结

不想更新 Homebrew 往往有两个原因，害怕潜在的风险和对工具的不熟悉，我之前也是这样。写这篇文章最开始是为了帮我记录常用的命令方便以后查阅的。希望它也能帮到你。

原文地址：https://segmentfault.com/a/1190000004353419

想整理一下 brew 的命令，看到这篇文章写得很好，就转载过来了。

Unity Shader 学习笔记（5）第一个简单Shader

参考书籍：《Unity Shader 入门精要》
作者源码：https://github.com/candycat1992/Unity_Shaders_Book
项目源码：https://github.com/ZeroChiLi/ShaderTest

色彩由法线值控制

Shader "Custom/Chapter 5/SimpleShader" {
    Properties {
        _Color ("Color Tint",Color) = (1.0,1.0,1.0,1.0)     // 声明一个Color类型的属性
    }

    SubShader {
        Pass {
            CGPROGRAM

            #pragma vertex vert                             // 告诉Unity，vert函数包含顶点着色器代码
            #pragma fragment frag                           // frag函数包含片元着色器代码

            fixed4 _Color;                                  // Cg中声明和属性名称类型相同的变量，这样才能在Cg中使用

            struct a2v {                                    // application To vertex shader 应用到着色器
                float4 vertex : POSITION;                   // POSITION：把模型的顶点坐标填充到 vertex
                float3 normal : NORMAL;                     // NORMAL：法线方向填充到 normal，范围[-1.0,1.0]
                float4 texcoord : TEXCOORD0;                // TEXCOORD0：纹理坐标填充到 texcoord
            };

            struct v2f {                                    // 顶点到片着色器
                float4 pos : SV_POSITION;                   // 裁剪空间中的顶点坐标
                fixed3 color : COLOR0;                      // 存储颜色信息
            };

            v2f vert(a2v v) {
                v2f o;
                o.pos = UnityObjectToClipPos(v.vertex);     // mul(UNITY_MATRIX_MVP,v),把顶点坐标从模型空间转到裁剪空间
                o.color = v.normal * 0.5 + fixed3(0.5,0.5,0.5);
                return o;   
            }

            float4 frag(v2f i) : SV_Target {    // SV_Target：把用户的输出颜色存到一个渲染目标中。这里输出到默认的帧缓存中
                fixed3 c = i.color;
                c *= _Color.rgb;                // 使用_Color属性来控制输出颜色
                return fixed4(c,1.0);           // 将插值后的i.color显示到屏幕
            }

            ENDCG
        }
    }
    FallBack "Diffuse"
}

// POSITION：传入模型的顶坐标到v。
// SV_POSITION：输出裁切空间的顶点坐标。
float4 vert(float4 v : POSITION) : SV_POSITION {
    return mul(UNITY_MATRIX_MVP, v);
}

关于 node 环境升级到 v8^ 以上，node-sass 报错的解决方法

今天给同事电脑升级了一下系统，顺便升级了所有的软件，发现原来好好的项目报错了。报错大致信息如下：

 ERROR  Failed to compile with 1 errors                                                                      下午1:56:26

 error  in ./src/components/Hello.vue

Module build failed: Error: Missing binding /Users/fungleo/Sites/MyWork/vuedemo2/node_modules/node-sass/vendor/darwin-x64-57/binding.node
Node Sass could not find a binding for your current environment: OS X 64-bit with Node.js 8.x

Found bindings for the following environments:
  - OS X 64-bit with Node.js 6.x

This usually happens because your environment has changed since running `npm install`.
Run `npm rebuild node-sass --force` to build the binding for your current environment.
    at module.exports (/Users/fungleo/Sites/MyWork/vuedemo2/node_modules/node-sass/lib/binding.js:15:13)
    at Object.<anonymous> (/Users/fungleo/Sites/MyWork/vuedemo2/node_modules/node-sass/lib/index.js:14:35)
    at Module._compile (module.js:635:30)
    at Object.Module._extensions..js (module.js:646:10)
    at Module.load (module.js:554:32)
    at tryModuleLoad (module.js:497:12)
    at Function.Module._load (module.js:489:3)
    at Module.require (module.js:579:17)
    at require (internal/module.js:11:18)
    at Object.<anonymous> (/Users/fungleo/Sites/MyWork/vuedemo2/node_modules/sass-loader/lib/loader.js:3:14)
    at Module._compile (module.js:635:30)
    at Object.Module._extensions..js (module.js:646:10)
    at Module.load (module.js:554:32)
    at tryModuleLoad (module.js:497:12)
    at Function.Module._load (module.js:489:3)
    at Module.require (module.js:579:17)

 @ ./~/vue-style-loader!./~/css-loader?{"minimize":false,"sourceMap":false}!./~/vue-loader/lib/style-compiler?{"vue":true,"id":"data-v-2d1bdf0c","scoped":false,"hasInlineConfig":false}!./~/sass-loader/lib/loader.js?{"sourceMap":false}!./~/vue-loader/lib/selector.js?type=styles&index=0!./src/components/Hello.vue 4:14-394 13:3-17:5 14:22-402
 @ ./src/components/Hello.vue
 @ ./src/router/index.js
 @ ./src/main.js
 @ multi ./build/dev-client ./src/main.js

> Listening at http://localhost:8080

这段代码是我升级node之后，在我的电脑上复制出来的。但大概就是这么个意思，里面根据不同的项目位置什么的，会有所不同。

简单的说，这段代码就是告诉你，node-sass 不兼容 node v8 的版本。那就很好解决了。在当前项目下面执行

npm i node-sass -D

然后项目就恢复正常了。

当项目出错之后，不要着急，仔细看下报错代码，实在不行用翻译工具翻译一下。一般来说，是很快能够找到解决方法的。

本文由 FungLeo 原创，允许转载，但转载必须保留首发链接。

package com.dataStructure.heap;

import java.util.Arrays;

public class IndexMaxHeap {
    // 最大索引堆中的数据
    private Integer[] data;
    // 最大索引堆中的索引
    private int[] indexes;
    private int count;
    private int capacity;

    // 构造函数, 构造一个空堆, 可容纳capacity个元素
    public IndexMaxHeap(int capacity) {
        this.capacity = capacity;
        data = new Integer[capacity + 1];
        indexes = new int[capacity + 1];
        count = 0;
    }

    // 返回索引堆中的元素个数
    public int size() {
        return count;
    }

    // 返回一个布尔值, 表示索引堆中是否为空
    public boolean isEmpty() {
        return count == 0;
    }

    // 向最大索引堆中插入一个新的元素, 新元素的索引为i, 元素为item
    // 传入的i对用户而言,是从0索引的
    public void insert(int i, Integer integer) {
        i += 1;
        data[i] = integer;
        indexes[count + 1] = i;
        count++;
        shiftUp(count);
    }

    // 从最大索引堆中取出堆顶元素, 即索引堆中所存储的最大数据
    public Integer extractMax() {
        Integer ret = data[indexes[1]];
        swapIndexes(1, count);
        count--;
        shiftDown(1);
        return ret;
    }

    // 从最大索引堆中取出堆顶元素的索引
    public int extractMaxIndexes() {
        int ret = indexes[1] - 1;
        swapIndexes(1, count);
        count--;
        shiftDown(1);
        return ret;
    }

    // 获取最大索引堆中的堆顶元素
    public int getMax() {
        return data[indexes[1]];
    }

    // 获取最大索引堆中的堆顶元素的索引
    public int getMaxIndex() {
        return indexes[1]-1;
    }

    // 获取最大索引堆中索引为i的元素
    public Integer getInteger(int i) {
        return data[i + 1];
    }

    // 将最大索引堆中索引为i的元素修改为newItem
    public void change(int i, Integer newInteger) {
        i += 1;
        data[i] = newInteger;
        // 找到indexes[j] = i, j表示data[i]在堆中的位置
        // 之后shiftUp(j), 再shiftDown(j)
        for (int j = 1; j <= count; i++) {
            if (indexes[j] == i) {
                shiftUp(j);
                shiftDown(j);
                return;
            }
        }
    }

    // 交换索引堆中的索引i和j
    private void swapIndexes(int i, int j) {
        int temp = indexes[i];
        indexes[i] = indexes[j];
        indexes[j] = temp;
    }

    //********************
    //* 最大索引堆核心辅助函数
    //********************

    // 索引堆中, 数据之间的比较根据data的大小进行比较, 但实际操作的是索引
    private void shiftUp(int k) {
        while (k > 1 && data[indexes[k / 2]].compareTo(data[indexes[k]]) < 0) {
            swapIndexes(k, k / 2);
            k /= 2;
        }
    }

    // 索引堆中, 数据之间的比较根据data的大小进行比较, 但实际操作的是索引
    private void shiftDown(int k) {
        while (2 * k <= count) {
            int j = 2 * k;
            if (j + 1 <= count && data[indexes[j + 1]].compareTo(data[indexes[j]]) > 0) {
                j++;
            }
            if (data[indexes[k]].compareTo(data[indexes[j]]) > 0) break;
            swapIndexes(k, j);
            k = j;
        }
    }

    // 测试索引堆中的索引数组index
    // 注意:这个测试在向堆中插入元素以后, 不进行extract操作有效
    public boolean testIndexes() {
        int[] copyIndexes = new int[count + 1];
        for (int i = 0; i <= count; i++) {
            copyIndexes[i] = indexes[i];
        }
        copyIndexes[0] = 0;
        Arrays.sort(copyIndexes);

        // 在对索引堆中的索引进行排序后, 应该正好是1...count这count个索引
        boolean res = true;
        for (int i = 1; i <= count; i++) {
            if (copyIndexes[i - 1] + 1 != copyIndexes[i]) {
                res = false;
                break;
            }
        }
        if (!res) {
            System.out.println("Error!");
            return false;
        }
        return true;
    }

    // 测试 IndexMaxHeap
    public static void main(String[] args) {

        int N = 1000000;
        IndexMaxHeap indexMaxHeap = new IndexMaxHeap(N);
        for (int i = 0; i < N; i++)
            indexMaxHeap.insert(i, (int) (Math.random() * N));
        System.out.println(indexMaxHeap.testIndexes());
    }


}

在索引中，我们除了data之外，还引入了indexes。data中存放原始数据，indexes中存放的是索引。这里要注意：无论是data数组中的元素，还是indexes数组中的元素，都不构成堆！是谁构成了堆？是下面的这个数组：

data[indexes[1]], data[indexes[2]], data[indexes[3]], ..., data[indexes[n]]

换句话说，我们可以这样理解indexes。将data中的元素组织成一个堆以后，把他们原先对应的序号依次取出来，构成的数组就是索引数组的内容。而data的内容再恢复回去，不要动。在索引堆中，我们可以看到，shiftUp和shiftDown操作只改变索引数组indexes的内容，而不去动data。data就静静地躺在那里，看indexes数组变来变去。最后真正要使用data的时候，只要用indexes相应的元素做索引，指向data就好了。

所以，我们的getMax函数是这样的：

Item getMax(){    
    assert( count > 0 );    
    return data[indexes[1]];    
}

看，永远取indexes数组第一个元素为索引所对应的那个data，真正改变的是indexes：）

Swagger2简介

本次教程是Spring Boot中使用Swagger2构建RESTful APIS
Swagger 是一个规范和完整的框架，用于生成、描述、调用和可视化 RESTful 风格的 Web 服务。（如图）

Swagger除了查看接口功能外，还提供了调试测试功能。（如图）
新增博客

查看所有博客

修改博客

查看单个博客

删除博客

SpringBoot整合Swagger2

配置pom.xml,引入Swagger2架包

<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>2.7.0</version>
</dependency>
<dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>2.7.0</version>
</dependency>

在RunApplication.java同级下创建Swagger2.java

package com.javazhan;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.*;
import springfox.documentation.service.*;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
 * Created by yando on 2017/11/10.
 */

@Configuration
@EnableSwagger2
public class Swagger2 {

    @Bean
    public Docket api() {
        return new Docket(DocumentationType.SWAGGER_2)
                .select()
                .apis(RequestHandlerSelectors.any())
                .build()
                .apiInfo(apiInfo());
    }

    private ApiInfo apiInfo() {
        return new ApiInfoBuilder()
                .title("Spring Boot中使用Swagger2构建RESTful APIS")
                .description("HTTP对外开放接口")
                .version("1.0.0")
                .termsOfServiceUrl("http://blog.csdn.net/wenteryan")
                .license("Spring Boot 入门+实战（提供源码哟）")
                .licenseUrl("http://blog.csdn.net/column/details/15021.html")
                .build();
    }
}

创建实体类 Blog.java（略）

创建ABlogController.java

package com.javazhan.controller.admin;

import com.javazhan.domain.Blog;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.*;

import java.util.*;

/**
 * Created by yando on 2017/11/13.
 */
@RestController
@RequestMapping(value = "/admin/blog")
public class ABlogController {

    static Map<Long, Blog> blogs = Collections.synchronizedMap(new HashMap<Long, Blog>()) ;

    @ApiOperation(value = "后台管理查询所有博客")
    @RequestMapping(value = "", method = RequestMethod.GET)
    public List<Blog> getBlogList() {
        List<Blog> list = new ArrayList<Blog>(blogs.values()) ;
        return list ;
    }

    @ApiOperation(value = "新增博客", notes = "根据博客对象")
    @ApiImplicitParam(name = "blog", value = "博客信息实体blog", required = true, dataType = "Blog")
    @RequestMapping(value = "/add", method = RequestMethod.POST)
    public Map addBlog(@RequestBody Blog blog) {
        blogs.put(blog.getId(), blog) ;
        Map map = new HashMap() ;
        map.put("message", "新增成功") ;
        map.put("code", "0000") ;
        return map ;
    }

    @ApiOperation(value = "获取博客信息", notes = "根据ID获取博客对象")
    @ApiImplicitParam(name = "id", value = "博客ID", required = true, paramType="path", dataType = "Long")
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public Blog getBlogById(@PathVariable Long id) {
        Blog blog = new Blog() ;
        blog = blogs.get(id) ;
        return blog ;
    }

    @ApiOperation(value = "修改博客信息", notes = "根据传过来的博客对象修改博客信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "id", value = "博客ID", required = true, paramType="path", dataType = "Long"),
            @ApiImplicitParam(name = "blog", value = "博客信息实体blog", required = true, dataType = "Blog")
    })
    @RequestMapping(value = "/{id}", method = RequestMethod.PUT)
    public Map updateBlog(@PathVariable Long id, @RequestBody Blog blog) {
        Blog b = blogs.get(blog.getId()) ;
        b.setId(blog.getId()) ;
        b.setName(blog.getName()) ;
        blogs.put(b.getId(), b) ;
        Map map = new HashMap() ;
        map.put("message", "修改成功") ;
        map.put("code", "0000") ;
        return map ;
    }

    @ApiOperation(value = "删除博客信息", notes = "根据ID删除博客对象")
    @ApiImplicitParam(name = "id", value = "博客ID", required = true, paramType="path", dataType = "Long")
    @RequestMapping(value = "/{id}", method = RequestMethod.DELETE)
    public Map deleteBlog(@PathVariable Long id) {
        blogs.remove(id) ;
        Map map = new HashMap() ;
        map.put("message", "删除成功") ;
        map.put("code", "0000") ;
        return map ;
    }
}

运行RunApplication.java
访问地址：http://localhost:8080/swagger-ui.html

更多教程请参考官方文档

源码下载

Spring Boot中使用Swagger2构建RESTful APIS（含源码）

版权声明：本文为博主原创文章，未经博主允许不得转载。转载请注明出处：http://blog.csdn.net/wenteryan

#include <syslog.h>

void openlog(const char* ident, int options, int facility);
void syslog(int priority, const char* message, ...);
void closelog(void);