精华内容
下载资源
问答
  • Redis基础:主从模式的优点和缺点

    千次阅读 2020-06-07 09:19:54
    上篇文章使用容器化的方式构建了一个一主两丛的Redis服务,这篇文章继续在此基础之上确认一下相应的优点和缺点

    上篇文章使用容器化的方式构建了一个一主两丛的Redis服务,这篇文章继续在此基础之上确认一下相应的优点和缺点。

    环境构建

    详细可参看:https://liumiaocn.blog.csdn.net/article/details/106582498
    使用一个docker-compose.yml即可拉起一主两丛的Redis,详细如下所示:

    liumiaocn:redis liumiao$ cat docker-compose.yml
    version: '2'
    services:
      # redis master
      master:
        image: redis:6.0.4
        container_name: redis-master
        restart: always
        command: redis-server --port 6379 --requirepass liumiaocn@server  --appendonly yes
        ports:
          - 6379:6379
        volumes:
          - ./data:/data
    
      # redis slave 1 
      slave1:
        image: redis:6.0.4
        container_name: redis-slave-1
        restart: always
        command: redis-server --slaveof 192.168.31.242 6379 --port 6380 --requirepass liumiaocn@server --masterauth liumiaocn@server  --appendonly yes
        ports:
          - 6380:6380
        volumes:
          - ./data:/data
    
      # redis slave 2 
      slave2:
        image: redis:6.0.4
        container_name: redis-slave-2
        restart: always
        command: redis-server --slaveof 192.168.31.242 6379 --port 6381 --requirepass liumiaocn@server --masterauth liumiaocn@server  --appendonly yes
        ports:
          - 6381:6381
        volumes:
          - ./data:/data
    liumiaocn:redis liumiao$ 
    liumiaocn:redis liumiao$ docker-compose up -d
    Creating network "redis_default" with the default driver
    Creating redis-master  ... done
    Creating redis-slave-2 ... done
    Creating redis-slave-1 ... done
    liumiaocn:redis liumiao$ docker-compose ps
        Name                   Command               State                Ports              
    -----------------------------------------------------------------------------------------
    redis-master    docker-entrypoint.sh redis ...   Up      0.0.0.0:6379->6379/tcp          
    redis-slave-1   docker-entrypoint.sh redis ...   Up      6379/tcp, 0.0.0.0:6380->6380/tcp
    redis-slave-2   docker-entrypoint.sh redis ...   Up      6379/tcp, 0.0.0.0:6381->6381/tcp
    liumiaocn:redis liumiao$
    

    优点:主写,从读,降低读的压力

    liumiaocn:redis liumiao$ redis-cli -p 6379
    127.0.0.1:6379> auth liumiaocn@server
    OK
    127.0.0.1:6379> keys *
    (empty list or set)
    127.0.0.1:6379> set greeting "hello liumiao"
    OK
    127.0.0.1:6379> get greeting
    "hello liumiao"
    127.0.0.1:6379> keys *
    1) "greeting"
    127.0.0.1:6379> 
    127.0.0.1:6379> exit
    liumiaocn:redis liumiao$
    

    Master写,Slave可读

    liumiaocn:redis liumiao$ redis-cli -p 6380
    127.0.0.1:6380> auth liumiaocn@server
    OK
    127.0.0.1:6380> keys *
    1) "greeting"
    127.0.0.1:6380> get greeting
    "hello liumiao"
    127.0.0.1:6380>
    
    liumiaocn:redis liumiao$ redis-cli -p 6381
    127.0.0.1:6381> auth liumiaocn@server
    OK
    127.0.0.1:6381> keys *
    1) "greeting"
    127.0.0.1:6381> get greeting
    "hello liumiao"
    127.0.0.1:6381> 
    

    缺点:Master的写的压力难以降低

    从节点无法进行写操作

    liumiaocn:redis liumiao$ redis-cli -p 6380
    127.0.0.1:6380> auth liumiaocn@server
    OK
    127.0.0.1:6380> set name "liumiao"
    (error) READONLY You can't write against a read only replica.
    127.0.0.1:6380> 
    

    注:虽然也可设定使得slave可写,但在数据的同步等方面使用上都有很多问题。主从模式最为常见的场景就是主写从读的模式,读写分离,降低读的压力。

    优点:从节点宕机,影响较小

    事前确认

    liumiaocn:redis liumiao$ docker ps
    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                              NAMES
    19ed07e594b2        redis:6.0.4         "docker-entrypoint.s…"   8 minutes ago       Up 8 minutes        6379/tcp, 0.0.0.0:6381->6381/tcp   redis-slave-2
    66e84b66542e        redis:6.0.4         "docker-entrypoint.s…"   8 minutes ago       Up 8 minutes        0.0.0.0:6379->6379/tcp             redis-master
    e1bc030fc87d        redis:6.0.4         "docker-entrypoint.s…"   8 minutes ago       Up 8 minutes        6379/tcp, 0.0.0.0:6380->6380/tcp   redis-slave-1
    liumiaocn:redis liumiao$ redis-cli -p 6380
    127.0.0.1:6380> auth liumiaocn@server
    OK
    127.0.0.1:6380> keys *
    1) "greeting"
    127.0.0.1:6380> 
    127.0.0.1:6380> exit
    liumiaocn:redis liumiao$
    

    模拟slave1宕机

    liumiaocn:redis liumiao$ docker stop redis-slave-1
    redis-slave-1
    liumiaocn:redis liumiao$ 
    liumiaocn:redis liumiao$ redis-cli -p 6380
    Could not connect to Redis at 127.0.0.1:6380: Connection refused
    not connected> exit
    liumiaocn:redis liumiao$ 
    

    剩余一主一从仍可使用

    liumiaocn:redis liumiao$ redis-cli -p 6379
    127.0.0.1:6379> auth liumiaocn@server
    OK
    127.0.0.1:6379> keys *
    1) "greeting"
    127.0.0.1:6379> set version 0.1
    OK
    127.0.0.1:6379> keys *
    1) "version"
    2) "greeting"
    127.0.0.1:6379> exit
    liumiaocn:redis liumiao$ 
    liumiaocn:redis liumiao$ redis-cli -p 6381
    127.0.0.1:6381> auth liumiaocn@server
    OK
    127.0.0.1:6381> keys *
    1) "greeting"
    2) "version"
    127.0.0.1:6381> exit
    liumiaocn:redis liumiao$ 
    

    启动slave1后即可继续使用

    liumiaocn:redis liumiao$ docker start redis-slave-1
    redis-slave-1
    liumiaocn:redis liumiao$ 
    liumiaocn:redis liumiao$ docker ps
    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                              NAMES
    19ed07e594b2        redis:6.0.4         "docker-entrypoint.s…"   11 minutes ago      Up 11 minutes       6379/tcp, 0.0.0.0:6381->6381/tcp   redis-slave-2
    66e84b66542e        redis:6.0.4         "docker-entrypoint.s…"   11 minutes ago      Up 11 minutes       0.0.0.0:6379->6379/tcp             redis-master
    e1bc030fc87d        redis:6.0.4         "docker-entrypoint.s…"   11 minutes ago      Up 2 seconds        6379/tcp, 0.0.0.0:6380->6380/tcp   redis-slave-1
    liumiaocn:redis liumiao$ 
    

    启动后,在宕机期间更新的数据也已经同步

    liumiaocn:redis liumiao$ redis-cli -p 6380
    127.0.0.1:6380> auth liumiaocn@server
    OK
    127.0.0.1:6380> keys *
    1) "greeting"
    2) "version"
    127.0.0.1:6380> get version
    "0.1"
    127.0.0.1:6380> exit
    liumiaocn:redis liumiao$
    

    缺点:主节点宕机,无法继续使用

    liumiaocn:redis liumiao$ docker ps
    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                              NAMES
    19ed07e594b2        redis:6.0.4         "docker-entrypoint.s…"   13 minutes ago      Up 13 minutes       6379/tcp, 0.0.0.0:6381->6381/tcp   redis-slave-2
    66e84b66542e        redis:6.0.4         "docker-entrypoint.s…"   13 minutes ago      Up 13 minutes       0.0.0.0:6379->6379/tcp             redis-master
    e1bc030fc87d        redis:6.0.4         "docker-entrypoint.s…"   13 minutes ago      Up About a minute   6379/tcp, 0.0.0.0:6380->6380/tcp   redis-slave-1
    liumiaocn:redis liumiao$ docker stop redis-master
    redis-master
    liumiaocn:redis liumiao$ docker ps
    CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                              NAMES
    19ed07e594b2        redis:6.0.4         "docker-entrypoint.s…"   13 minutes ago      Up 13 minutes       6379/tcp, 0.0.0.0:6381->6381/tcp   redis-slave-2
    e1bc030fc87d        redis:6.0.4         "docker-entrypoint.s…"   13 minutes ago      Up About a minute   6379/tcp, 0.0.0.0:6380->6380/tcp   redis-slave-1
    liumiaocn:redis liumiao$ 
    

    只能连接从节点进行读操作,无法执行写操作,需要进行手工干预

    liumiaocn:redis liumiao$ redis-cli -p 6380
    127.0.0.1:6380> auth liumiaocn@server
    OK
    127.0.0.1:6380> keys *
    1) "greeting"
    2) "version"
    127.0.0.1:6380> 
    127.0.0.1:6380> set name "liumiao"
    (error) READONLY You can't write against a read only replica.
    127.0.0.1:6380> 
    
    展开全文
  • CopyOnWriteArrayList的优点和缺点

    千次阅读 2015-02-27 15:49:43
    CopyOnWriteArrayList的优点和缺点

      CopyOnWriteArrayList是ArrayList的一个线程安全的变体,其中所有可变操作(add、set等等)都是通过对底层数组进行一次新的复制来实现的。

         这一般需要很大的开销,但是当遍历操作的数量大大超过可变操作的数量时,这种方法可能比其他替代方法 有效。在不能或不想进行同步遍历,但又需要从并发线程中排除冲突时,它也很有用。“快照”风格的迭代器方法在创建迭代器时使用了对数组状态的引用。此数组在迭代器的生存期内不会更改,因此不可能发生冲突,并且迭代器保证不会抛出ConcurrentModificationException。创建迭代器以后,迭代器就不会反映列表的添加、移除或者更改。在迭代器上进行的元素更改操作(remove、set和add)不受支持。这些方法将抛出UnsupportedOperationException。

    允许使用所有元素,包括null。

        内存一致性效果:当存在其他并发 collection 时,将对象放入CopyOnWriteArrayList之前的线程中的操作 happen-before随后通过另一线程从CopyOnWriteArrayList中访问或移除该元素的操作。 

       这种情况一般在多线程操作时,一个线程对list进行修改。一个线程对list进行for时会出现java.util.ConcurrentModificationException错误。

       下面来看一个列子:两个线程一个线程for一个线程修改list的值。


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    package com.lucky.concurrent.list;
     import java.util.ArrayList; import java.util.List; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors;
     public class CopyOnWriteArrayListDemo {
        /**
         * 读线程
         *
         *
         */
        private static class ReadTask implements Runnable {
            List<String> list;
      
            public ReadTask(List<String> list) {
                this.list = list;
            }
      
            public void run() {
                for (String str : list) {
                    System.out.println(str);
                }
            }
        }
        /**
         * 写线程
         *
         *
         */
        private static class WriteTask implements Runnable {
            List<String> list;
            int index;
      
            public WriteTask(List<String> list, int index) {
                this.list = list;
                this.index = index;
            }
      
            public void run() {
                list.remove(index);
                list.add(index, "write_" + index);
            }
        }
      
        public void run() {
            final int NUM = 10;
            List<String> list = new ArrayList<String>();
            for (int i = 0; i < NUM; i++) {
                list.add("main_" + i);
            }
            ExecutorService executorService = Executors.newFixedThreadPool(NUM);
            for (int i = 0; i < NUM; i++) {
                executorService.execute(new ReadTask(list));
                executorService.execute(new WriteTask(list, i));
            }
            executorService.shutdown();
        }
      
        public static void main(String[] args) {
            new CopyOnWriteArrayListDemo().run();
        }
    }
    运行结果:


    从结果中可以看出来。在多线程情况下报错。其原因就是多线程操作结果:那这个种方案不行我们就换个方案。用jdk自带的类CopyOnWriteArrayList来做容器。这个类和ArrayList最大的区别就是add(E) 的时候。容器会自动copy一份出来然后再尾部add(E)。看源码:


    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    /**
        * Appends the specified element to the end of this list.
        *
        * @param e element to be appended to this list
        * @return <tt>true</tt> (as specified by {@link Collection#add})
        */
       public boolean add(E e) {
       final ReentrantLock lock = this.lock;
       lock.lock();
       try {
           Object[] elements = getArray();
           int len = elements.length;
           Object[] newElements = Arrays.copyOf(elements, len + 1);
           newElements[len] = e;
           setArray(newElements);
           return true;
       } finally {
           lock.unlock();
       }
       }

    用到了Arrays.copyOf 方法。这样导致每次操作的都不是同一个引用。也就不会出现java.util.ConcurrentModificationException错误。
    换了种方案看代码:


    1
    2
    //      List<String> list = new ArrayList<String>();      
      CopyOnWriteArrayList<String> list = new CopyOnWriteArrayList<String>();
    也就把容器list换成了 CopyOnWriteArrayList,其他的没变。线程里面的list不用改。因为 CopyOnWriteArrayList实现的也是list<E> 接口。看结果:

    其结果没报错。
    CopyOnWriteArrayList add(E
    ) 和remove(int index)都是对新的数组进行修改和新增。所以在多线程操作时不会出现java.util.ConcurrentModificationException错误。


    优点:

    CopyOnWriteArrayList适合使用在读操作远远大于写操作的场景里,比如缓存。发生修改时候做copy,新老版本分离,

    保证读的高性能,适用于以读为主的情况。


    缺点:

    CopyOnWriteArrayList采用“写入时复制”策略,对容器的写操作将导致的容器中基本数组的复制,性能开销较大。所以在有写操作的情况下,CopyOnWriteArrayList性能不佳,而且如果容器容量较大的话容易造成溢出。


    展开全文
  • Python的优点和缺点

    万次阅读 2017-10-16 14:07:16
    Python的优点和缺点 本节内容如下: Python的优点 Python的缺点 使用Python的知名网站 Python的优点 1. 简单 Python的语法非常优雅,甚至没有像其他语言的大括号,分号等特殊符号,代表了一种极简主义的设计...

    Python的优点和缺点

    本节内容如下:

    • Python的优点
    • Python的缺点
    • 使用Python的知名网站

    Python的优点

    1. 简单 Python的语法非常优雅,甚至没有像其他语言的大括号,分号等特殊符号,代表了一种极简主义的设计思想。阅读Python程序像是在读英语。

    2. 易学 Python入手非常快,学习曲线非常低,可以直接通过命令行交互环境来学习Python编程。

    3. 免费/开源 Python的所有内容都是免费开源的,这意味着你不需要花一分钱就可以免费使用Python,并且你可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改动、把它的一部分用于新的自由软件中。

    4. 自动内存管理 如果你了解C语言、C++语言你就会知道内存管理给你带来很大麻烦,程序非常容易出现内存方面的漏洞。但是在Python中内存管理是自动完成的,你可以专注于程序本身。

    5. 可以移植 由于Python是开源的,它已经被移植到了大多数平台下面,例如:Windows、MacOS、Linux、Andorid、iOS等等。

    6. 解释性 大多数计算机编程语言都是编译型的,在运行之前需要将源码编译为操作系统可以执行的二进制格式(0110格式的),这样大型项目编译过程非常消耗时间,而Python语言写的程序不需要编译成二进制代码。你可以直接从源代码运行程序。在计算机内部,Python解释器把源代码转换成称为字节码的中间形式,然后再把它翻译成计算机使用的机器语言并运行。

    7. 面向对象 Python既支持面向过程,又支持面向对象,这样编程就更加灵活。

    8. 可扩展 Python除了使用Python本身编写外,还可以混合使用像C语言、Java语言等编写。

    9. 丰富的第三方库 Python具有本身有丰富而且强大的库,而且由于Python的开源特性,第三方库也非常多,例如:在web开发、爬虫、科学计算等等

    Python的缺点

    Python虽然有很多优点,但是它也不是完美的,它也有自身的缺点。

    1. 速度慢 由于,Python是解释型语言,所有它的速度会比,C、C++慢一些,但是不影响使用。由于,现在的硬件配置都非常高,基本上没有影响,除非是一些实时性比较强的程序可能会受到一些影响,但是也有解决办法,可以嵌入C程序。

    2. 强制缩进 如果你有其他语言的编程经验,例如:C语言或者Java语言,那么Python的强制缩进一开始会让你很不习惯。但是如果你习惯了Python的缩进语法,你会觉得它非常优雅。

    3. 单行语句 由于Python可以在尾部不写分号,所以一行只能有一条语句,这可能也算是一个不足吧,不过这真的微不足道。

    使用Python的知名网站

    国内的:

    • 豆瓣
    • 果壳
    • 知乎
    • Sohu邮箱

    国外的:

    • youtube
    • Gmail邮箱
    • Dropbox

    等等等等

    展开全文
  • java优点和缺点

    万次阅读 2018-08-22 18:08:41
    Java:优点用几个词形容一下Java语言: 优美, 严谨, 健壮,不易出错.当然, 使用也非常的广泛: 常年盘踞编程人员数量排行榜第一名!各种库也灰常多: akullpp/awesome-java · GitHub同样的代码, 相比C++(甚至python), ...

    Java:优点用几个词形容一下Java语言: 优美, 严谨, 健壮,不易出错.当然, 使用也非常的广泛: 常年盘踞编程人员数量排行榜第一名!各种库也灰常多: akullpp/awesome-java · GitHub同样的代码, 相比C++(甚至python), Java代码出BUG的概率要小点(当然,写的时候一般会比python长). Java从语言设计上尽量避免了程序员犯错, 比如自动垃圾回收, 抛弃无符号类型, 安全的枚举, 编译期泛型检查(Java1.5之后加入的泛型,但是只是用来做编译器检查,运行时跟以前一样), 强制的异常处理(遇到异常必须catch或者申明throws) 等等(当然,某些特性python也有.)Java标准库和好多第三方代码都充斥着浓浓的设计感!!!, 各种设计模式到处可见. 从下面的语句可以看出一点来:new BufferedInputStream(new FileInputStream(new File(“somepath”)))
    尼玛, 好多字, 看我的:C:fopen(“somepath”, “r”)
    Python:open(“somepath”)
    Java代码多,但是API可复用行更强,选择更多(我想一次读完文件,不要buffer呢?)因为健壮安全,所以Java成了企业级后台的标准. 想想银行后台, 关键地方出点bug可不得了.缺点:要敲好多代码, 参考上面的例子…没有Python那些奇葩特性, 灵活性不足,怎么写你还是Java, 而Python可以写的像Javascript/Lisp/Matlab…..简单来说, Python是给人设计的(人生苦短,请用Python), C/C++更像是为机器设计的,而Java则介于两者之间.如果你是高手, 写出的代码没什么bug, 也不用怎么调试, 那推荐你用python(前提是他的慢你能忍受. 当然,高手眼里, 他会的就是最好的….)如果你写的代码bug多,大部分时间在调试代码,你可能需要了解一下Java, 或者写足够多的testcase.

    展开全文
  • FreeMarker的优点和缺点

    千次阅读 2010-12-16 20:43:00
    FreeMarker的优点和缺点 标签: FreeMarker优点 FreeMarker缺点 模板引擎 struts2 一、 FreeMarker简介 FreeMarker是一个用Java语言编写的模板引擎,它基于模板来生成文本输出。 所谓模板,就是一份已经...
  • python优点和缺点

    千次阅读 2018-08-22 18:07:12
    优点: 语法简洁优美, 功能强大, 标准库跟第三方库灰常强大, 应用领域非常广: vinta/awesome-python · GitHub(跟PHP形成宣明对比!)语言方面, 举几个例子:一切都是对象!!!类(class本身)/函数/类方法是callable的...
  • NoSql简介、优点和缺点

    千次阅读 2019-01-27 12:18:32
    存储,它的结构不固定,每一条记录可以有不一样的键,每条记录可以根据需要增加一些自己的键值对,这样就不会局限于固定的结构,可以减少一些时间空间的开销 在优势方面主要体现在下面几点:  简单的扩展 ...
  • Iframe的优点和缺点

    万次阅读 2016-02-19 20:36:50
    3.网页如果为了统一风格,头部版本都是一样的,就可以成一个页面,用iframe来嵌套,可以增加代码的可重用。 4.如果遇到加载缓慢的第三方内容如图标广告,这些问题可以由iframe来解决。 5.重载页面时不需要...
  • MyBatis的优点和缺点

    千次阅读 2015-11-20 13:39:17
    2. sql在xml里,便于统一管理优化。 3. 解除sql与程序代码的耦合。 4. 提供映射标签,支持对象与数据库的orm字段关系映射 5. 提供对象关系映射标签,支持对象关系组建维护 6. 提供xml标签,支持编写动态sql...
  • Spring的优点和缺点

    万次阅读 2015-04-12 21:13:38
    Spring是一个轻量级的DIAOP容器框架。 说它轻量级有一大部分原因是相对与EJB的(虽然本人从没有接触过EJB的应用),重要的是,Spring是非侵入式的(所谓非侵入式就是远程调试 而不植入,spring不再用new的方式来...
  • JDBC的优点和缺点

    千次阅读 2013-11-04 21:20:51
    JDBC的优点:  直接底层操作,提供了很简单、便捷的访问数据库的方法,跨平台性比较强。灵活性比较强,可以很复杂的SQL语句。 JDBC的缺点:  因为JAVA是面向对象的,JDBC没有做到使数据能够面向对象的编程,...
  • 编者按每个人,都有自己的优点和缺点优点,没得说,越来越好,喜闻乐见的局面,是大家都乐意见到的。缺点,不想提,不越来越差已经对得起你了。想要克服缺点,实在是太难了。小雷同学,最近对这个问题,颇有领悟,...
  • HBase有什么优点和缺点

    千次阅读 2018-11-22 21:42:01
    HBase的优点:  (1)大:一个表可以有上十亿行,上百万列。 (2)面向列:面向列(簇)的存储权限控制,列(簇)独立检索。 (3)稀疏:对于为空(null)的列并不占用内存空间,因此,表可以设计的非常稀疏。 (4)多版本...
  • java反射机制的优点和缺点

    千次阅读 2020-09-26 23:09:24
    一、反射机制的优点 首先,反射机制极大的提高了程序的灵活性扩展性,降低模块的耦合性,提高自身的适应能力。 其次,通过反射机制可以让程序创建控制任何类的对象,无需提前硬编码目标类。 再次,使用反射机制...
  • Redis是什么?什么作用?优点和缺点

    万次阅读 多人点赞 2018-08-03 08:36:05
    通常而言目前的数据库分类有几种,包括 SQL/NSQL,,关系数据库,键值数据库等等 等,分类的标准也不以,Redis本质上也是一种键值数据库的,但它在保持键值数据库简单快捷特点的同时,又吸收了部分关系数据库的优点。...
  • Python的特点(优点和缺点

    万次阅读 2019-07-02 15:07:11
    其实,这两个缺点并不是什么大问题,首先,由于目前计算机的硬件速度越来越快,软件工程往往更关注开发过程的效率可靠性,而不是软件的运行效率;至于第二个问题就更不是问题了,现在软件行业的大势本就是开源,...
  • 数据库 索引的优点和缺点

    千次阅读 2019-04-12 20:29:42
    索引: 为什么要创建索引呢?这是因为,创建索引可以大大提高系统的性能。 第一,通过创建唯一性索引,可以保证...第四,在使用分组排序 子句进行数据检索时,同样可以显著减少查询中分组排序的时间。 第五...
  • spring IoC 优点和缺点

    千次阅读 2015-05-28 13:04:29
    Interface Driven Design接口驱动,接口驱动有很多好处,可以提供不同灵活的子类实现,增加代码稳定健壮性等等,但是接口一定是需要实现的,也就是如下语句迟早要执 行:AInterface a = new AInterfac
  • yolov3算法优点缺点_优点缺点

    千次阅读 2020-08-11 15:09:31
    yolov3算法优点缺点Naive Bayes: A classification algorithm under a supervised learning group based on Probabilistic logic. This is one of the simplest machine learning algorithms of all. Logistic ...
  • 选用pg的优点和缺点

    千次阅读 2019-03-18 19:48:11
    当然,要说有什么缺点或者遗憾,那还是有几个的: 因为使用了MVCC,数据库需要定期VACUUM,需要定期维护表索引避免膨胀导致性能下降。 没有很好的开源 集群 监控方案(或者太丑!),需要自己做。 慢查询...
  • python语言的优点和缺点

    千次阅读 2018-01-26 09:37:43
    python作为一门高级编程语言,它的诞生虽然很偶然,但是它得到程序员的喜爱却是必然之路。 龟叔给Python的定位是“优雅”、“明确...python语言的优点  ⑴作为初学python的科班出身的小白,python非常简单,非常适
  • freemarker 的优点和缺点

    千次阅读 2014-02-26 11:20:34
    所谓模板,就是一份已经好了基本内容,有着固定格式的文档,其中空出或者用占位符标识的内容,由使用者来填充,不同的使用者给出的数据是不同的。在模板中的占位符,在模板运行时,由模板引擎来解析模板,并采用...
  • redis redis的优点和缺点

    千次阅读 2019-04-30 15:55:00
    1. redis的优点 速度快 (1) 因为数据存在内存中,类似于 HashMap ,HashMap 的优势就是查找操作的时间复杂度都是O (1) 。 (2) Redis 本质上是一个 Key-Value 类型的内存数据库,很像Memcached ,整个...
  • Python语言的优点和缺点

    千次阅读 2017-05-08 13:57:42
     ⑵既是优点也是缺点,python的开源性是的Python语言不能加密,但是目前国内市场纯粹靠编写软件卖给客户的越来越少,网站移动应用不需要给客户源代码,所以这个问题就是问题了。国随着时间的推移,很多国内软件...
  • 以下例句主要从IEEE期刊中收集而来,方便论文的时候借鉴。 优点: The main advantage of the proposed approach is its applicability to both steady-state and transient operating conditions.  ...
  • 对比Java,Kotlin的优点和缺点

    千次阅读 2019-05-04 09:22:25
    下面Kotlin的优点,大部分已经在《为什么Kotlin比Java能大量减少代码》介绍了,但是为了本文的完整性,再次完整展示. Kotlin优点 1. 简化空对象的处理(防止空指针) val userName = a?.b?.c?.d ?: "" 详细文档,可参考:...
  • postgresql-X2 的优点和缺点

    千次阅读 2015-12-11 10:32:30
    优点: 1.无中心节点,SQL可以发送给任何一台协调器,扩展性比较好 2.应用可以读写任何节点,结果都会一样。 3.在整个集群上实现了ACID
  • 存储过程触发器的优点和缺点

    千次阅读 2015-12-22 16:57:27
    首先介绍触发器 触发器是一种特殊类型的存储过程,当使用...外部程序的存储过程,xp开头,动态链接库形式存在,也放在master
  • 总结--反射的优点和缺点

    千次阅读 2018-09-29 11:19:49
    优点: java的反射机制就是增加程序的灵活性,避免将程序死到代码里, 例如: 实例化一个 person()对象, 不使用反射, new person(); 如果想变成 实例化 其他类, 那么必须修改源代码,并重新编译。 使用反射...
  • 分析灰盒测试优点和缺点

    千次阅读 2015-09-20 12:31:34
    “灰盒” 测试以程序的主要性能主要功能为测试依据,测试方法主要根据程序的程序图、功能说明书以及测试者的实践经验来设计。下面从灰盒测试的优缺点开始说起。  一、几个基本概念  首先,把一些基本概念...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 374,419
精华内容 149,767
关键字:

优点和缺点怎么写