• 关于

    java 线程里终止

    的搜索结果

回答

"当我们调用Java命令运行某个Java程序时,该命令将会启动一个Java虚拟机进程,不管该Java程序有多么复杂,该程序启动了多少个线程,它们都处于该Java虚拟机进程里。正如前面介绍的,同一个JVM的所有线程、所有变量都处于同一个进程里,它们都使用该JVM进程的内存区。当系统出现以下几种情况时,JVM进程将被终止。 程序运行到最后正常结束。 程序运行到使用System.exit()或Runtime.getRuntime().exit()代码处结束程序。 程序执行过程中遇到未捕获的异常或错误而结束。 程序所在平台强制结束了JVM进程。"

星尘linger 2020-04-12 19:20:34 0 浏览量 回答数 0

回答

Java 线程的生命周期中,在 Thread 类里有一个枚举类型 State,定义了线程的几种状态,分别有: New Runnable Blocked Waiting Timed Waiting Terminated 各个状态说明: 初始状态 - NEW 声明: public static final Thread.State NEW 实现 Runnable 接口和继承 Thread 可以得到一个线程类,new 一个实例出来,线程就进入了初始状态。 RUNNABLE 声明: public static final Thread.State RUNNABLE 2.1. 就绪状态 就绪状态只是说你资格运行,调度程序没有挑选到你,你就永远是就绪状态。 调用线程的 start() 方法,此线程进入就绪状态。 当前线程 sleep() 方法结束,其他线程 join() 结束,等待用户输入完毕,某个线程拿到对象锁,这些线程也将进入就绪状态。 当前线程时间片用完了,调用当前线程的 yield() 方法,当前线程进入就绪状态。 锁池里的线程拿到对象锁后,进入就绪状态。 2.2. 运行中状态 线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。 阻塞状态 - BLOCKED 声明: public static final Thread.State BLOCKED 阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。 等待 - WAITING 声明: public static final Thread.State WAITING 处于这种状态的线程不会被分配 CPU 执行时间,它们要等待被显式地唤醒,否则会处于无限期等待的状态。 超时等待 - TIMED_WAITING 声明: public static final Thread.State TIMED_WAITING 处于这种状态的线程不会被分配 CPU 执行时间,不过无须无限期等待被其他线程显示地唤醒,在达到一定时间后它们会自动唤醒。 终止状态 - TERMINATED 声明: public static final Thread.State TERMINATED 当线程的 run() 方法完成时,或者主线程的 main() 方法完成时,我们就认为它终止了。这个线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦终止了,就不能复生。 在一个终止的线程上调用 start() 方法,会抛出 java.lang.IllegalThreadStateException 异常。 以下实例演示了如何获取线程的状态: Main.java 文件 // Java 程序 - 演示线程状态 class thread implements Runnable { public void run() { // thread2 - 超时等待 try { Thread.sleep(1500); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("State of thread1 while it called join() method on thread2 -"+ Test.thread1.getState()); try { Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } } } public class Test implements Runnable { public static Thread thread1; public static Test obj; public static void main(String[] args) { obj = new Test(); thread1 = new Thread(obj); // 创建 thread1,现在是初始状态 System.out.println("State of thread1 after creating it - " + thread1.getState()); thread1.start(); // thread1 - 就绪状态 System.out.println("State of thread1 after calling .start() method on it - " + thread1.getState()); } public void run() { thread myThread = new thread(); Thread thread2 = new Thread(myThread); // 创建 thread1,现在是初始状态 System.out.println("State of thread2 after creating it - "+ thread2.getState()); thread2.start(); // thread2 - 就绪状态 System.out.println("State of thread2 after calling .start() method on it - " + thread2.getState()); // moving thread1 to timed waiting state try { //moving - 超时等待 Thread.sleep(200); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("State of thread2 after calling .sleep() method on it - "+ thread2.getState() ); try { // 等待 thread2 终止 thread2.join(); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("State of thread2 when it has finished it's execution - " + thread2.getState()); } } 以上代码运行输出结果为: State of thread1 after creating it - NEW State of thread1 after calling .start() method on it - RUNNABLE State of thread2 after creating it - NEW State of thread2 after calling .start() method on it - RUNNABLE State of thread2 after calling .sleep() method on it - TIMED_WAITING State of thread1 while it called join() method on thread2 -WAITING State of thread2 when it has finished it's execution - TERMINATED

问问小秘 2020-02-13 17:58:55 0 浏览量 回答数 0

问题

Java 如何让一个线程运行特定的时间终止?

蛮大人123 2019-12-01 20:02:36 1335 浏览量 回答数 2

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

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

问题

对症下药:Tomcat停机过程分析与线程处理方法

驻云科技 2019-12-01 21:08:52 43219 浏览量 回答数 3

回答

要么开JMX监控一下tomcat的信息,有必要dump一下堆栈分析一下看看? tomcat挂掉大多情况都是OOM但是在系统日志里没有看到OOM的信息,有没有这种情况,系统杀掉了java进程,但是没有在日志里记录呢???谢谢!!! 这是监控日志,有哪位大侠能看出什么异常来吗???回复 @wyl_root:被内核干掉的进程都会有系统级别的日志。 另外检查下tomcat的目录下有没有stacktrace.log这样的文件?如果java进程异常挂掉的时候,有可能会在家目录下生成一个堆栈跟踪的log。还可以尝试升级一下java的小版本,比如某些低版本的java有BUG,会导致进程意外终止,这种情况升级一下java版本可能就能解决。最后,jvisualvm比jconsole直观的多,带有堆dump与分析功能。 好的,非常感谢,那我用jvisualvm监控试一下,后续给您回复,谢谢!!! 看看线程数量,是不是哪里不停的在开线程没有结束掉。一般系统好像有个最大线程数。超过了会关闭进程。我们以前遇见过类似问题。监控了线程数,java挂掉的时候线程数没有超过阀值,我设置的阀值是1800 jvisualvm比jconsole只能在JAVA虚拟机运行的时候监控,设置JVM参数,让虚拟机挂掉之后自动输出dump文件!~~然后再看您好,请问添加什么参数可以使虚拟机挂掉之后自动输出dump文件啊??? 您好,这是java进程异常中断时的jvisualvm截图信息,没看出什么异常信息,还请哪位大侠帮忙分析一下,是否能看出什么异常,谢谢!!! 很久以前的问题了,有好的解决思路么? 

爱吃鱼的程序员 2020-06-09 16:01:14 0 浏览量 回答数 0

回答

这个取决于驱动的实现。mongodb的API并不规定这个线程安全性(如Javascript驱动就没有线程)。从你的描述中估计你用的是Java。在Java驱动里面 Bulk API用的是ArrayList所以理论上线程安全没有保障。不过你在调用的一般就是insert(),相当于 ArrayList.add(),实际使用中多线程同时调用add()并没有太多问题。如果安全一点的话,就像你所做的一样,使用一个线程安全List,自己来维护这个队列,最后一次性交给MongoDB驱动来execute。关于第3个问题,这个和连接没有直接的关系。bulk操作可以使用一个,也可以对不同操作使用连接池内的不同连接(bulk操作内部会对所有操作按类型进行分组,每个组都是自己的一个网络请求)。不一定是一个长连接。如果连接断掉,对于orderedBulkOp 这个bulk操作就会失败并终止;对于unorderedBulkOp,会忽略错误并继续剩下的操作。另外, 上述讨论针对于2.6。 2.4或以前会有所不同。

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

问题

对症下药:Tomcat停机过程分析与线程处理方法

驻云科技 2019-12-01 21:36:46 4001 浏览量 回答数 0

问题

Java技术1000问(3)【精品问答】

问问小秘 2020-06-02 14:27:10 42 浏览量 回答数 1

回答

如果对什么是线程、什么是进程仍存有疑惑,请先Google之,因为这两个概念不在本文的范围之内。 用多线程只有一个目的,那就是更好的利用cpu的资源,因为所有的多线程代码都可以用单线程来实现。说这个话其实只有一半对,因为反应“多角色”的程序代码,最起码每个角色要给他一个线程吧,否则连实际场景都无法模拟,当然也没法说能用单线程来实现:比如最常见的“生产者,消费者模型”。 很多人都对其中的一些概念不够明确,如同步、并发等等,让我们先建立一个数据字典,以免产生误会。 多线程:指的是这个程序(一个进程)运行时产生了不止一个线程 并行与并发: 并行:多个cpu实例或者多台机器同时执行一段处理逻辑,是真正的同时。 并发:通过cpu调度算法,让用户看上去同时执行,实际上从cpu操作层面不是真正的同时。并发往往在场景中有公用的资源,那么针对这个公用的资源往往产生瓶颈,我们会用TPS或者QPS来反应这个系统的处理能力。 并发与并行 线程安全:经常用来描绘一段代码。指在并发的情况之下,该代码经过多线程使用,线程的调度顺序不影响任何结果。这个时候使用多线程,我们只需要关注系统的内存,cpu是不是够用即可。反过来,线程不安全就意味着线程的调度顺序会影响最终结果,如不加事务的转账代码: void transferMoney(User from, User to, float amount){ to.setMoney(to.getBalance() + amount); from.setMoney(from.getBalance() - amount); } 同步:Java中的同步指的是通过人为的控制和调度,保证共享资源的多线程访问成为线程安全,来保证结果的准确。如上面的代码简单加入@synchronized关键字。在保证结果准确的同时,提高性能,才是优秀的程序。线程安全的优先级高于性能。 好了,让我们开始吧。我准备分成几部分来总结涉及到多线程的内容: 扎好马步:线程的状态 内功心法:每个对象都有的方法(机制) 太祖长拳:基本线程类 九阴真经:高级多线程控制类 扎好马步:线程的状态 先来两张图: 线程状态 线程状态转换 各种状态一目了然,值得一提的是"blocked"这个状态:线程在Running的过程中可能会遇到阻塞(Blocked)情况 调用join()和sleep()方法,sleep()时间结束或被打断,join()中断,IO完成都会回到Runnable状态,等待JVM的调度。 调用wait(),使该线程处于等待池(wait blocked pool),直到notify()/notifyAll(),线程被唤醒被放到锁定池(lock blocked pool ),释放同步锁使线程回到可运行状态(Runnable) 对Running状态的线程加同步锁(Synchronized)使其进入(lock blocked pool ),同步锁被释放进入可运行状态(Runnable)。 此外,在runnable状态的线程是处于被调度的线程,此时的调度顺序是不一定的。Thread类中的yield方法可以让一个running状态的线程转入runnable。内功心法:每个对象都有的方法(机制) synchronized, wait, notify 是任何对象都具有的同步工具。让我们先来了解他们 monitor 他们是应用于同步问题的人工线程调度工具。讲其本质,首先就要明确monitor的概念,Java中的每个对象都有一个监视器,来监测并发代码的重入。在非多线程编码时该监视器不发挥作用,反之如果在synchronized 范围内,监视器发挥作用。 wait/notify必须存在于synchronized块中。并且,这三个关键字针对的是同一个监视器(某对象的监视器)。这意味着wait之后,其他线程可以进入同步块执行。 当某代码并不持有监视器的使用权时(如图中5的状态,即脱离同步块)去wait或notify,会抛出java.lang.IllegalMonitorStateException。也包括在synchronized块中去调用另一个对象的wait/notify,因为不同对象的监视器不同,同样会抛出此异常。 再讲用法: synchronized单独使用: 代码块:如下,在多线程环境下,synchronized块中的方法获取了lock实例的monitor,如果实例相同,那么只有一个线程能执行该块内容 复制代码 public class Thread1 implements Runnable { Object lock; public void run() { synchronized(lock){ ..do something } } } 复制代码 直接用于方法: 相当于上面代码中用lock来锁定的效果,实际获取的是Thread1类的monitor。更进一步,如果修饰的是static方法,则锁定该类所有实例。 public class Thread1 implements Runnable { public synchronized void run() { ..do something } } synchronized, wait, notify结合:典型场景生产者消费者问题 复制代码 /** * 生产者生产出来的产品交给店员 */ public synchronized void produce() { if(this.product >= MAX_PRODUCT) { try { wait(); System.out.println("产品已满,请稍候再生产"); } catch(InterruptedException e) { e.printStackTrace(); } return; } this.product++; System.out.println("生产者生产第" + this.product + "个产品."); notifyAll(); //通知等待区的消费者可以取出产品了 } /** * 消费者从店员取产品 */ public synchronized void consume() { if(this.product <= MIN_PRODUCT) { try { wait(); System.out.println("缺货,稍候再取"); } catch (InterruptedException e) { e.printStackTrace(); } return; } System.out.println("消费者取走了第" + this.product + "个产品."); this.product--; notifyAll(); //通知等待去的生产者可以生产产品了 } 复制代码 volatile 多线程的内存模型:main memory(主存)、working memory(线程栈),在处理数据时,线程会把值从主存load到本地栈,完成操作后再save回去(volatile关键词的作用:每次针对该变量的操作都激发一次load and save)。 volatile 针对多线程使用的变量如果不是volatile或者final修饰的,很有可能产生不可预知的结果(另一个线程修改了这个值,但是之后在某线程看到的是修改之前的值)。其实道理上讲同一实例的同一属性本身只有一个副本。但是多线程是会缓存值的,本质上,volatile就是不去缓存,直接取值。在线程安全的情况下加volatile会牺牲性能。太祖长拳:基本线程类 基本线程类指的是Thread类,Runnable接口,Callable接口Thread 类实现了Runnable接口,启动一个线程的方法:  MyThread my = new MyThread();  my.start(); Thread类相关方法:复制代码 //当前线程可转让cpu控制权,让别的就绪状态线程运行(切换)public static Thread.yield() //暂停一段时间public static Thread.sleep() //在一个线程中调用other.join(),将等待other执行完后才继续本线程。    public join()//后两个函数皆可以被打断public interrupte() 复制代码 关于中断:它并不像stop方法那样会中断一个正在运行的线程。线程会不时地检测中断标识位,以判断线程是否应该被中断(中断标识值是否为true)。终端只会影响到wait状态、sleep状态和join状态。被打断的线程会抛出InterruptedException。Thread.interrupted()检查当前线程是否发生中断,返回booleansynchronized在获锁的过程中是不能被中断的。 中断是一个状态!interrupt()方法只是将这个状态置为true而已。所以说正常运行的程序不去检测状态,就不会终止,而wait等阻塞方法会去检查并抛出异常。如果在正常运行的程序中添加while(!Thread.interrupted()) ,则同样可以在中断后离开代码体 Thread类最佳实践:写的时候最好要设置线程名称 Thread.name,并设置线程组 ThreadGroup,目的是方便管理。在出现问题的时候,打印线程栈 (jstack -pid) 一眼就可以看出是哪个线程出的问题,这个线程是干什么的。 如何获取线程中的异常 不能用try,catch来获取线程中的异常Runnable 与Thread类似Callable future模式:并发模式的一种,可以有两种形式,即无阻塞和阻塞,分别是isDone和get。其中Future对象用来存放该线程的返回值以及状态 ExecutorService e = Executors.newFixedThreadPool(3); //submit方法有多重参数版本,及支持callable也能够支持runnable接口类型.Future future = e.submit(new myCallable());future.isDone() //return true,false 无阻塞future.get() // return 返回值,阻塞直到该线程运行结束 九阴真经:高级多线程控制类 以上都属于内功心法,接下来是实际项目中常用到的工具了,Java1.5提供了一个非常高效实用的多线程包:java.util.concurrent, 提供了大量高级工具,可以帮助开发者编写高效、易维护、结构清晰的Java多线程程序。1.ThreadLocal类 用处:保存线程的独立变量。对一个线程类(继承自Thread)当使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程提供独立的变量副本,所以每一个线程都可以独立地改变自己的副本,而不会影响其它线程所对应的副本。常用于用户登录控制,如记录session信息。 实现:每个Thread都持有一个TreadLocalMap类型的变量(该类是一个轻量级的Map,功能与map一样,区别是桶里放的是entry而不是entry的链表。功能还是一个map。)以本身为key,以目标为value。主要方法是get()和set(T a),set之后在map里维护一个threadLocal -> a,get时将a返回。ThreadLocal是一个特殊的容器。2.原子类(AtomicInteger、AtomicBoolean……) 如果使用atomic wrapper class如atomicInteger,或者使用自己保证原子的操作,则等同于synchronized //返回值为booleanAtomicInteger.compareAndSet(int expect,int update) 该方法可用于实现乐观锁,考虑文中最初提到的如下场景:a给b付款10元,a扣了10元,b要加10元。此时c给b2元,但是b的加十元代码约为:复制代码 if(b.value.compareAndSet(old, value)){ return ;}else{ //try again // if that fails, rollback and log} 复制代码 AtomicReference对于AtomicReference 来讲,也许对象会出现,属性丢失的情况,即oldObject == current,但是oldObject.getPropertyA != current.getPropertyA。这时候,AtomicStampedReference就派上用场了。这也是一个很常用的思路,即加上版本号3.Lock类  lock: 在java.util.concurrent包内。共有三个实现: ReentrantLockReentrantReadWriteLock.ReadLockReentrantReadWriteLock.WriteLock 主要目的是和synchronized一样, 两者都是为了解决同步问题,处理资源争端而产生的技术。功能类似但有一些区别。 区别如下:复制代码 lock更灵活,可以自由定义多把锁的枷锁解锁顺序(synchronized要按照先加的后解顺序)提供多种加锁方案,lock 阻塞式, trylock 无阻塞式, lockInterruptily 可打断式, 还有trylock的带超时时间版本。本质上和监视器锁(即synchronized是一样的)能力越大,责任越大,必须控制好加锁和解锁,否则会导致灾难。和Condition类的结合。性能更高,对比如下图: 复制代码 synchronized和Lock性能对比 ReentrantLock    可重入的意义在于持有锁的线程可以继续持有,并且要释放对等的次数后才真正释放该锁。使用方法是: 1.先new一个实例 static ReentrantLock r=new ReentrantLock(); 2.加锁       r.lock()或r.lockInterruptibly(); 此处也是个不同,后者可被打断。当a线程lock后,b线程阻塞,此时如果是lockInterruptibly,那么在调用b.interrupt()之后,b线程退出阻塞,并放弃对资源的争抢,进入catch块。(如果使用后者,必须throw interruptable exception 或catch)     3.释放锁    r.unlock() 必须做!何为必须做呢,要放在finally里面。以防止异常跳出了正常流程,导致灾难。这里补充一个小知识点,finally是可以信任的:经过测试,哪怕是发生了OutofMemoryError,finally块中的语句执行也能够得到保证。 ReentrantReadWriteLock 可重入读写锁(读写锁的一个实现)   ReentrantReadWriteLock lock = new ReentrantReadWriteLock()  ReadLock r = lock.readLock();  WriteLock w = lock.writeLock(); 两者都有lock,unlock方法。写写,写读互斥;读读不互斥。可以实现并发读的高效线程安全代码4.容器类 这里就讨论比较常用的两个: BlockingQueueConcurrentHashMap BlockingQueue阻塞队列。该类是java.util.concurrent包下的重要类,通过对Queue的学习可以得知,这个queue是单向队列,可以在队列头添加元素和在队尾删除或取出元素。类似于一个管  道,特别适用于先进先出策略的一些应用场景。普通的queue接口主要实现有PriorityQueue(优先队列),有兴趣可以研究 BlockingQueue在队列的基础上添加了多线程协作的功能: BlockingQueue 除了传统的queue功能(表格左边的两列)之外,还提供了阻塞接口put和take,带超时功能的阻塞接口offer和poll。put会在队列满的时候阻塞,直到有空间时被唤醒;take在队 列空的时候阻塞,直到有东西拿的时候才被唤醒。用于生产者-消费者模型尤其好用,堪称神器。 常见的阻塞队列有: ArrayListBlockingQueueLinkedListBlockingQueueDelayQueueSynchronousQueue ConcurrentHashMap高效的线程安全哈希map。请对比hashTable , concurrentHashMap, HashMap5.管理类 管理类的概念比较泛,用于管理线程,本身不是多线程的,但提供了一些机制来利用上述的工具做一些封装。了解到的值得一提的管理类:ThreadPoolExecutor和 JMX框架下的系统级管理类 ThreadMXBeanThreadPoolExecutor如果不了解这个类,应该了解前面提到的ExecutorService,开一个自己的线程池非常方便:复制代码 ExecutorService e = Executors.newCachedThreadPool(); ExecutorService e = Executors.newSingleThreadExecutor(); ExecutorService e = Executors.newFixedThreadPool(3); // 第一种是可变大小线程池,按照任务数来分配线程, // 第二种是单线程池,相当于FixedThreadPool(1) // 第三种是固定大小线程池。 // 然后运行 e.execute(new MyRunnableImpl()); 复制代码 该类内部是通过ThreadPoolExecutor实现的,掌握该类有助于理解线程池的管理,本质上,他们都是ThreadPoolExecutor类的各种实现版本。请参见javadoc: ThreadPoolExecutor参数解释 翻译一下:复制代码 corePoolSize:池内线程初始值与最小值,就算是空闲状态,也会保持该数量线程。maximumPoolSize:线程最大值,线程的增长始终不会超过该值。keepAliveTime:当池内线程数高于corePoolSize时,经过多少时间多余的空闲线程才会被回收。回收前处于wait状态unit:时间单位,可以使用TimeUnit的实例,如TimeUnit.MILLISECONDS workQueue:待入任务(Runnable)的等待场所,该参数主要影响调度策略,如公平与否,是否产生饿死(starving)threadFactory:线程工厂类,有默认实现,如果有自定义的需要则需要自己实现ThreadFactory接口并作为参数传入。 阿里云优惠券地址https://promotion.aliyun.com/ntms/yunparter/invite.html?userCode=nb3paa5b

景凌凯 2019-12-02 01:40:35 0 浏览量 回答数 0

回答

ThreadGroup概述在java中为了方便线程管理出现了线程组ThreadGroup的概念,每个ThreadGroup可以同时包含多个子线程和多个子线程组,在一个进程中线程组是以树形的方式存在,通常情况下根线程组是system。system线程组下是main线程组,默认情况下第一级应用自己的线程组是通过main线程组创建出来的。 public class ThreadGroupTest { public static void main(String[] args) throws InterruptedException { //主线程对应的线程组 printGroupInfo(Thread.currentThread());//线程组为main父线程组为system //新建线程,系统默认的线程组 Thread appThread = new Thread(()->{},"appThread"); printGroupInfo(appThread);//线程组为main父线程组为system //自定义线程组 ThreadGroup factoryGroup=new ThreadGroup("factory"); Thread workerThread=new Thread(factoryGroup,()->{},"worker"); printGroupInfo(workerThread);//线程组为factory,父线程组为main //设置父线程组 ThreadGroup deviceGroup=new ThreadGroup(factoryGroup,"device"); Thread pcThread=new Thread(deviceGroup,()->{},"pc"); printGroupInfo(pcThread);//线程组为device,父线程组为factory } static void printGroupInfo(Thread t) { ThreadGroup group = t.getThreadGroup(); System.out.println("thread " + t.getName() + " group name is "+ group.getName() + " max priority is " + group.getMaxPriority() + " thread count is " + group.activeCount() + " parent group is "+ (group.getParent()==null?null:group.getParent().getName())); ThreadGroup parent=group; do { ThreadGroup current = parent; parent = parent.getParent(); if (parent == null) { break; } System.out.println(current.getName() +" Group's parent group name is "+parent.getName()); } while (true); System.out.println("--------------------------"); } }ThreadGroup线程组的操作线程组信息的获取 public int activeCount(); // 获得当前线程组中线程数目, 包括可运行和不可运行的public int activeGroupCount(); //获得当前线程组中活动的子线程组的数目public int enumerate(Thread list[]); //列举当前线程组中的线程public int enumerate(ThreadGroup list[]); //列举当前线程组中的子线程组public final int getMaxPriority(); //获得当前线程组中最大优先级public final String getName(); //获得当前线程组的名字public final ThreadGroup getParent(); //获得当前线程组的父线程组public boolean parentOf(ThreadGroup g); //判断当前线程组是否为指定线程的父线程public boolean isDaemon(); //判断当前线程组中是否有监护线程public void list(); //列出当前线程组中所有线程和子线程名线程组的操作 public final void resume(); //使被挂起的当前组内的线程恢复到可运行状态public final void setDaemon (boolean daemon); //指定一个线程为当前线程组的监护线程public final void setMaxPriority(int pri); //设置当前线程组允许的最大优先级public final void stop();//终止当前线程组中所有线程public final void suspend(); //挂起当前线程组中所有线程public String toStrinng(); //将当前线程组转换为String类的对象public class ThreadGroupDemo { public static void main(String[] args) throws InterruptedException { // 创建5个线程,并入group里面进行管理 ThreadGroup threadGroup = new ThreadGroup("threadGroupTest1"); for (int i = 0; i < 5; i++) { Thread thread = new Thread(threadGroup,()->{ System.out.println("Thread Start " + Thread.currentThread().getName()); try { int value = (int)new Random((new Date()).getTime()).nextDouble()*100; System.out.printf("Thread %s doTask: %d\n", Thread.currentThread().getName(),value); TimeUnit.SECONDS.sleep(value); } catch (InterruptedException e) { System.out.printf("Thread %s: Interrupted\n", Thread.currentThread().getName()); return; } System.out.println("Thread end " + Thread.currentThread().getName()); }); thread.start(); TimeUnit.SECONDS.sleep(1); } //group信息 System.out.printf("Number of Threads: %d\n", threadGroup.activeCount()); System.out.printf("Information about the Thread Group\n"); threadGroup.list(); //复制group的thread信息 Thread[] threads = new Thread[threadGroup.activeCount()]; threadGroup.enumerate(threads); for (int i = 0; i < threadGroup.activeCount(); i++) { System.out.printf("Thread %s: %s\n", threads[i].getName(),threads[i].getState()); } //等待结束 while (threadGroup.activeCount() > 9) { try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } //中断group中的线程 threadGroup.interrupt(); } }

auto_answer 2019-12-02 01:49:32 0 浏览量 回答数 0

回答

finalize方法是Object提供的的实例方法,使用规则如下: 当对象不再被任何对象引用时,GC会调用该对象的finalize()方法 finalize()是Object的方法,子类可以覆盖这个方法来做一些系统资源的释放或者数据的清理 可以在finalize()让这个对象再次被引用,避免被GC回收;7a686964616f31333366306437但是最常用的目的还是做cleanup Java不保证这个finalize()一定被执行;但是保证调用finalize的线程没有持有任何user-visible同步锁。 在finalize里面抛出的异常会被忽略,同时方法终止。 当finalize被调用之后,JVM会再一次检测这个对象是否能被存活的线程访问得到,如果不是,则清除该对象。也就是finalize只能被调用一次;也就是说,覆盖了finalize方法的对象需要经过两个GC周期才能被清除。

景凌凯 2020-04-07 17:22:18 0 浏览量 回答数 0

回答

final   在java中,final可以用来修饰类,方法和变量(成员变量或局部变量)。下面将对其详细介绍。 1.1 修饰类   当用final修饰类的时,表明该类不能被其他类所继承。当我们需要让一个类永远不被继承,此时就可以用final修饰,但要注意: final类中所有的成员方法都会隐式的定义为final方法。 1.2 修饰方法 使用final方法的原因主要有两个:   (1) 把方法锁定,以防止继承类对其进行更改。   (2) 效率,在早期的java版本中,会将final方法转为内嵌调用。但若方法过于庞大,可能在性能上不会有多大提升。因此在最近版本中,不需要final方法进行这些优化了。 final方法意味着“最后的、最终的”含义,即此方法不能被重写。 注意:若父类中final方法的访问权限为private,将导致子类中不能直接继承该方法,因此,此时可以在子类中定义相同方法名的函数,此时不会与重写final的矛盾,而是在子类中重新地定义了新方法。复制代码 class A{ private final void getName(){ } } public class B extends A{ public void getName(){ } public static void main(String[]args){ System.out.println("OK"); } } 复制代码    1.3 修饰变量   final成员变量表示常量,只能被赋值一次,赋值后其值不再改变。类似于C++中的const。   当final修饰一个基本数据类型时,表示该基本数据类型的值一旦在初始化后便不能发生变化;如果final修饰一个引用类型时,则在对其初始化之后便不能再让其指向其他对象了,但该引用所指向的对象的内容是可以发生变化的。本质上是一回事,因为引用的值是一个地址,final要求值,即地址的值不发生变化。    final修饰一个成员变量(属性),必须要显示初始化。这里有两种初始化方式,一种是在变量声明的时候初始化;第二种方法是在声明变量的时候不赋初值,但是要在这个变量所在的类的所有的构造函数中对这个变量赋初值。   当函数的参数类型声明为final时,说明该参数是只读型的。即你可以读取使用该参数,但是无法改变该参数的值。       在java中,String被设计成final类,那为什么平时使用时,String的值可以被改变呢?   字符串常量池是java堆内存中一个特殊的存储区域,当我们建立一个String对象时,假设常量池不存在该字符串,则创建一个,若存在则直接引用已经存在的字符串。当我们对String对象值改变的时候,例如 String a="A"; a="B" 。a是String对象的一个引用(我们这里所说的String对象其实是指字符串常量),当a=“B”执行时,并不是原本String对象("A")发生改变,而是创建一个新的对象("B"),令a引用它。 finally   finally作为异常处理的一部分,它只能用在try/catch语句中,并且附带一个语句块,表示这段语句最终一定会被执行(不管有没有抛出异常),经常被用在需要释放资源的情况下。(×)(这句话其实存在一定的问题)   很多人都认为finally语句块一定会执行,但真的是这样么?答案是否定的,例如下面这个例子:      当我们去掉注释的三行语句,执行结果为:      为什么在以上两种情况下都没有执行finally语句呢,说明什么问题?   只有与finally对应的try语句块得到执行的情况下,finally语句块才会执行。以上两种情况在执行try语句块之前已经返回或抛出异常,所以try对应的finally语句并没有执行。   但是,在某些情况下,即使try语句执行了,finally语句也不一定执行。例如以下情况:      finally 语句块还是没有执行,为什么呢?因为我们在 try 语句块中执行了 System.exit (0) 语句,终止了 Java 虚拟机的运行。那有人说了,在一般的 Java 应用中基本上是不会调用这个 System.exit(0) 方法的。OK !没有问题,我们不调用 System.exit(0) 这个方法,那么 finally 语句块就一定会执行吗?   再一次让大家失望了,答案还是否定的。当一个线程在执行 try 语句块或者 catch 语句块时被打断(interrupted)或者被终止(killed),与其相对应的 finally 语句块可能不会执行。还有更极端的情况,就是在线程运行 try 语句块或者 catch 语句块时,突然死机或者断电,finally 语句块肯定不会执行了。可能有人认为死机、断电这些理由有些强词夺理,没有关系,我们只是为了说明这个问题。 易错点   在try-catch-finally语句中执行return语句。我们看如下代码:      答案:4,4,4 。 为什么呢?   首先finally语句在改代码中一定会执行,从运行结果来看,每次return的结果都是4(即finally语句),仿佛其他return语句被屏蔽掉了。   事实也确实如此,因为finally用法特殊,所以会撤销之前的return语句,继续执行最后的finally块中的代码。    finalize     finalize()是在java.lang.Object里定义的,也就是说每一个对象都有这么个方法。这个方法在gc启动,该对象被回收的时候被调用。其实gc可以回收大部分的对象(凡是new出来的对象,gc都能搞定,一般情况下我们又不会用new以外的方式去创建对象),所以一般是不需要程序员去实现finalize的。 特殊情况下,需要程序员实现finalize,当对象被回收的时候释放一些资源,比如:一个socket链接,在对象初始化时创建,整个生命周期内有效,那么就需要实现finalize,关闭这个链接。   使用finalize还需要注意一个事,调用super.finalize();   一个对象的finalize()方法只会被调用一次,而且finalize()被调用不意味着gc会立即回收该对象,所以有可能调用finalize()后,该对象又不需要被回收了,然后到了真正要被回收的时候,因为前面调用过一次,所以不会调用finalize(),产生问题。 所以,推荐不要使用finalize()方法,它跟析构函数不一样。

wangccsy 2019-12-02 01:48:34 0 浏览量 回答数 0

问题

Java 8 Lambda限制:报错

kun坤 2020-06-08 11:12:26 4 浏览量 回答数 1

问题

Netty实现原理浅析 1、总体结构 2、网络模型 3、 buffer 4、Ch?400报错

爱吃鱼的程序员 2020-06-04 11:53:36 3 浏览量 回答数 1

回答

存储在OSS上的文件,如何设置防盗链功能? 为了防止用户在OSS上的数据被其他人盗链,OSS支持基于HTTP header中表头字段referer的防盗链方法。 目前,只有通过OSS的控制台( http://i.aliyun.com/dashboard/instance?type=oss)可以对一个bucket设置referer字段的白名单和是否允许referer字段为空的请求访问。    例如,对于一个名为mydata的bucket,设置其referer白名单为 http://www.aliyun.com。则所有referer为 http://www.aliyun.com的请求才能访问mydata这个bucket中的Object。    细节分析: 1) 用户只有通过 URL 签名或者匿名访问 Object 时,才会做防盗链验证。请求的 Header 中有“Authorization”字段的,不会做防盗链验证。 2) 一个 bucket 可以支持多个 referer 参数,这些参数之间由“,”号分隔。 3) Referer 参数支持通配符“*”和“?”。 4) 用户可以设置是否允许 referer 字段为空的请求访问。 5) 白名单为空时,不会检查 referer 字段是否为空(不然所有的请求都会被拒绝)。 6) 白名单不为空,且设置了不允许 referer 字段为空的规则;则只有 referer 属于白名单的请求被允许,其他请求(包括 referer 为空的请求)会被拒绝。 7) 如果白名单不为空,但设置了允许 referer 字段为空的规则;则 referer 为空的请求和符合白名单的请求会被允许;其他请求都会被拒绝。 8) Bucket 的三种权限(private,public-read,public-read-write)都会检查 referer字段。       星号“*”: 可以使用星号代替0个或多个字符。如果正在查找以AEW开头的一个文件,但不记得文件名其余部分,可以输入AEW*,查找以AEW开头的所有文件类型的文件,如AEWT.txt、AEWU.EXE、AEWI.dll等。要缩小范围可以输入AEW*.txt,查找以AEW开头的所有文件类型并.txt为扩展名的文件如AEWIP.txt、AEWDF.txt。 问号“?”: 可以使用问号代替一个字符。如果输入love?,查找以love开头的一个字符结尾文件类型的文件,如lovey、lovei等。要缩小范围可以输入love?.doc,查找以love开头的一个字符结尾文件类型并.doc为扩展名的文件如lovey.doc、loveh.doc。    不允许Refer为空 可能有些人搞不明白,简单说就是直接在浏览器中输入图片URL,refer为空;从网页中点击打开图片则refer不为空。    注:资料参考API文档地址 http://help.aliyun.com/manual?&helpId=253        细节分析参考资料 http://www.amznz.com/aliyun-oss-referer/ ------------------------- 11.云服务器与OSS 上传文件,流量与请求次数是否收费? 云服务器与OSS之间通过内网地址上传或下载数据,属内网流量,是免费的。 阿里云服务器与OSS之间的内网访问通信地址为: http://oss-internal.aliyuncs.com (需用以上方式进行访问,方可计为内网流量) *  可通过cname方式或三级域名的方式访问文件 云服务器与OSS每次请求所产生的请求次数,不分内外网都会计费。 收费详情请参考 http://www.aliyun.com/product?type=oss#price 12.OSS API返回结果没有JSON格式的吗? 只有XML格式 13. 如何进行大文件上传? 1、有开发能力的用户:可以通过oss API或SDK来操作。 • 5GB以下文件或网络速度好的用户,可以使用PUT object 。 • 5GB以上或网络速度不好并且文件在100M以上的用户推荐使用 Multipart Upload 2、无开发基础客户可下载OSS客户端,请参考 http://bbs.aliyun.com/read.php?tid=95321 14.object怎么改名? 两种方法可以实现:1. 您可以删除原来的文件,上传新命名的文件也能达到改名的效果2. 您可以通过copy objcet 源文件复制成为一个新名字的文件。再把源文件删除即可 15.OSS中可以重命名bucket吗?是否支持object迁移? OSS的bucket暂不支持重命名,若需要其他名称建议您重新创建bucket。 OSS 提供了COPY objcet的功能,您可以将原bucekt下的文件COPY到新bucket即可。 16.咨询一下java sdk中的 ossclient对象是否是线程安全的? java sdk中的 ossclient对象是线程安全的 17.测试版PHP SDK中不能自动检测所需PHP模块,是什么原因? 1.使用phpinfo来查看PHP模块。使用PHPSDK需要配置CURL功能模。具体安装CURL的方法可参考: http://bbs.aliyun.com/read.php?tid=18967 ; 2.您可以下载最新的PHP SDK包。已支持自动检测所需PHP模块 http://www.aliyun.com/product?type=oss#resources 18.比如多个文件object, 直接指定多个object,生成一个url,打包一起下载? 目前oss不支持多个object打包下载。 此需求可以由上层应用逻辑进行处理。OSS服务提供平台级基础资源的存储支持。 19.OSS返回的文件网络路径,域名都是aliyun的吗? 是的。支持CNAME 同时现在支持绑定自己的域名 20.可以给出一个java实现生成url签名的代码示例吗? 生成签名以后的URL的示例代码如下: // Generate a presigned URL Date expires = new Date (new Date().getTime()   1000 * 60); // 1 minute to expire GeneratePresignedUrlRequest generatePresignedUrlRequest = new GeneratePresignedUrlRequest(bucketName, key); generatePresignedUrlRequest.setExpiration(expires); URL url = client.generatePresignedUrl(generatePresignedUrlRequest); System.out.println(url.toString()); 这段代码假定指定bucketName和key的Object已经上传到OSS,用户可以根据修改设定expires,即过期时间。更详细的操作可以参考OSSClient#generatePresignedUrl方法和GeneratePresignedUrlRequest类的帮助。 ------------------------- 21.OSS中url中可以实现授权文件上传吗? Oss中url中授权文件上传可以实现 java版代码示例如下:GeneratePresignedUrlRequest generatePresignedUrlRequest = 1)url中包含签名的好像能够实现文件的下载,阿里云能实现url中授权文件上传吗? new GeneratePresignedUrlRequest(bucketName, key); 2)java版代码示例如下: generatePresignedUrlRequest.setMethod(HttpMethod.PUT); generatePresignedUrlRequest.setExpiration(expires); generatePresignedUrlRequest.addUserMetadata("usermeta", "uservalue"); // If you need to set user metadata URL url = client.generatePresignedUrl(generatePresignedUrlRequest); 22.如何使用JAVA SDK源代码? 您可以使用jd decompiler等Java反编译的工具打开SDK的jar文件,即可以查看全部源代码。 23.为什么bucket下的文件都删除了,却还能查看到占用的空间,并且bucket也删除不了? 请确认您是否使用过UploadMultipart 的功能,如使用过,建议您可以通过UploadsList Multipart 查看是否存在已经被初始化但是未被Complete或者Abort的 Multipart Upload的part。如果有,则需再执行Abort Multipart Upload(来终止上次操作的 Multipart Upload,该命令会自动删除未完成的part)。 因为未完成合并的part,无法形成objcet, 所以通过object list是看不到这些残留的part 但这些都会产生占用空间量。 24.如何使用内网 ? 阿里云云服务器与OSS之间通过Bucket.oss-internal.aliyuncs.com(OSS内网请求域名)的方式请求,所产生的网络流量可享受内网流量免费。 25.无法上传大文件怎么办? 无法向OSS上传大文件。上传1KB以下的文件就可以,2KB以上的文件就不成功,请求发出去就收不到任何响应,直至超时。 解决办法是将本机的MTU设成1470(默认应该是1500) Linux下修改MTU的命令是:(以阿里云服务器oss走内网默认是eth0为例) ip link set dev eth0 mtu 1470 26.OSS支持bucket作为三级域名的访问方式? 三级域名外链访问: http://bucketname.oss.aliyuncs.com/object 例如: http://cloudstorage.oss.aliyuncs.com/pujing.jpg 普通外链访问: http://oss.aliyuncs.com/bucketname/object 例如: http://oss.aliyuncs.com/cloudstorage/pujing.jpg 温馨提示:如果你的bucket里面有下划线"_",那么由于不符合WWW规范,所以无法做为三级域名使用,只能使用普通外链访问方式。 ------------------------- 终于整理出来了 。。。。大半夜的 闹鬼啊 ------------------------- 回 6楼(kashi) 的帖子 谢谢支持 ------------------------- 回 5楼(yyd521) 的帖子 只要能帮到大家   应该的拉 ------------------------- Re:ReOSS官方帮助文档在此归类发布,常见问题基本能在这里找到答案。 引用第10楼pasahu于2013-07-20 20:53发表的 ReOSS官方帮助文档在此归类发布,常见问题基本能在这里找到答案。 : 快点吧 discuz  x2.5  3.0整出来吧。。搞些实在的。 你好  这个我们在做  很快  插件就出来了 ------------------------- 感谢夸奖

asky8 2019-12-02 01:36:19 0 浏览量 回答数 0

回答

Linux这么多命令,通常会让初学者望而生畏。下面是我结合日常工作,以及在公司的内部培训中,针对对Linux不是很熟悉的同学,精选的一批必须要搞懂的命令集合。 任何一个命令其实都是可以深入的,比如tail -f和tail -F的区别。我们不去关心,只使用最常见的示例来说明。本文不会教你具体的用法,那是抢man命令的饭碗。这只是个引导篇,力求简洁。 学习方式:多敲多打,用条件反射替代大脑记忆—如果你将来或者现在要用它来吃饭的话。其中,也有一些难啃的骨头,关注小姐姐味道微信公众号,我们一起用锋利的牙齿,来把它嚼碎。 内容: ✔ 目录操作 ✔ 文本处理 ✔ 压缩 ✔ 日常运维 ✔ 系统状态概览 ✔ 工作常用 目录操作 工作中,最常打交道的就是对目录和文件的操作。linux提供了相应的命令去操作他,并将这些命令抽象、缩写。 基本操作 可能是这些命令太常用了,多打一个字符都是罪过。所以它们都很短,不用阿拉伯数字,一个剪刀手就能数过来。 看命令。 mkdir 创建目录 make dir cp 拷贝文件 copy mv 移动文件 move rm 删除文件 remove 例子: # 创建目录和父目录a,b,c,d mkdir -p a/b/c/d # 拷贝文件夹a到/tmp目录 cp -rvf a/ /tmp/ # 移动文件a到/tmp目录,并重命名为b mv -vf a /tmp/b # 删除机器上的所有文件 rm -rvf / 漫游 linux上是黑漆漆的命令行,依然要面临人生三问:我是谁?我在哪?我要去何方? ls 命令能够看到当前目录的所有内容。ls -l能够看到更多信息,判断你是谁。 pwd 命令能够看到当前终端所在的目录。告诉你你在哪。 cd 假如你去错了地方,cd命令能够切换到对的目录。 find find命令通过筛选一些条件,能够找到已经被遗忘的文件。 至于要去何方,可能就是主宰者的意志了。 文本处理 这是是非常非常加分的技能。get到之后,也能节省更多时间来研究面向对象。 查看文件 cat 最常用的就是cat命令了,注意,如果文件很大的话,cat命令的输出结果会疯狂在终端上输出,可以多次按ctrl+c终止。 # 查看文件大小 du -h file # 查看文件内容 cat file less 既然cat有这个问题,针对比较大的文件,我们就可以使用less命令打开某个文件。 类似vim,less可以在输入/后进入查找模式,然后按n(N)向下(上)查找。 有许多操作,都和vim类似,你可以类比看下。 tail 大多数做服务端开发的同学,都了解这么命令。比如,查看nginx的滚动日志。 tail -f access.log tail命令可以静态的查看某个文件的最后n行,与之对应的,head命令查看文件头n行。但head没有滚动功能,就像尾巴是往外长的,不会反着往里长。 tail -n100 access.log head -n100 access.log 统计 sort和uniq经常配对使用。 sort可以使用-t指定分隔符,使用-k指定要排序的列。 下面这个命令输出nginx日志的ip和每个ip的pv,pv最高的前10 #2019-06-26T10:01:57+08:00|nginx001.server.ops.pro.dc|100.116.222.80|10.31.150.232:41021|0.014|0.011|0.000|200|200|273|-|/visit|sign=91CD1988CE8B313B8A0454A4BBE930DF|-|-|http|POST|112.4.238.213 awk -F"|" '{print $3}' access.log | sort | uniq -c | sort -nk1 -r | head -n10 其他 grep grep用来对内容进行过滤,带上--color参数,可以在支持的终端可以打印彩色,参数n则输出具体的行数,用来快速定位。 比如:查看nginx日志中的POST请求。 grep -rn --color POST access.log 推荐每次都使用这样的参数。 如果我想要看某个异常前后相关的内容,就可以使用ABC参数。它们是几个单词的缩写,经常被使用。 A after 内容后n行 B before 内容前n行 C count? 内容前后n行 就像是这样: grep -rn --color Exception -A10 -B2 error.log diff diff命令用来比较两个文件是否的差异。当然,在ide中都提供了这个功能,diff只是命令行下的原始折衷。对了,diff和patch还是一些平台源码的打补丁方式,你要是不用,就pass吧。 压缩 为了减小传输文件的大小,一般都开启压缩。linux下常见的压缩文件有tar、bzip2、zip、rar等,7z这种用的相对较少。 .tar 使用tar命令压缩或解压 .bz2 使用bzip2命令操作 .gz 使用gzip命令操作 .zip 使用unzip命令解压 .rar 使用unrar命令解压 最常用的就是.tar.gz文件格式了。其实是经过了tar打包后,再使用gzip压缩。 创建压缩文件 tar cvfz archive.tar.gz dir/ 解压 tar xvfz. archive.tar.gz 日常运维 开机是按一下启动按钮,关机总不至于是长按启动按钮吧。对了,是shutdown命令,不过一般也没权限-.-!。passwd命令可以用来修改密码,这个权限还是可以有的。 mount mount命令可以挂在一些外接设备,比如u盘,比如iso,比如刚申请的ssd。可以放心的看小电影了。 mount /dev/sdb1 /xiaodianying chown chown 用来改变文件的所属用户和所属组。 chmod 用来改变文件的访问权限。 这两个命令,都和linux的文件权限777有关。 示例: # 毁灭性的命令 chmod 000 -R / # 修改a目录的用户和组为 xjj chown -R xjj:xjj a # 给a.sh文件增加执行权限(这个太常用了) chmod a+x a.sh yum 假定你用的是centos,则包管理工具就是yum。如果你的系统没有wget命令,就可以使用如下命令进行安装。 yum install wget -y systemctl 当然,centos管理后台服务也有一些套路。service命令就是。systemctl兼容了service命令,我们看一下怎么重启mysql服务。 推荐用下面这个。 service mysql restart systemctl restart mysqld 对于普通的进程,就要使用kill命令进行更加详细的控制了。kill命令有很多信号,如果你在用kill -9,你一定想要了解kill -15以及kill -3的区别和用途。 su su用来切换用户。比如你现在是root,想要用xjj用户做一些勾当,就可以使用su切换。 su xjj su - xjj -可以让你干净纯洁的降临另一个账号,不出意外,推荐。 系统状态概览 登陆一台linux机器,有些命令能够帮助你快速找到问题。这些命令涵盖内存、cpu、网络、io、磁盘等。 uname uname命令可以输出当前的内核信息,让你了解到用的是什么机器。 uname -a ps ps命令能够看到进程/线程状态。和top有些内容重叠,常用。 找到java进程 ps -ef|grep java top 系统状态一览,主要查看。cpu load负载、cpu占用率。使用内存或者cpu最高的一些进程。下面这个命令可以查看某个进程中的线程状态。 top -H -p pid free top也能看内存,但不友好,free是专门用来查看内存的。包括物理内存和虚拟内存swap。 df df命令用来查看系统中磁盘的使用量,用来查看磁盘是否已经到达上限。参数h可以以友好的方式进行展示。 df -h ifconfig 查看ip地址,不啰嗦,替代品是ip addr命令。 ping 至于网络通不通,可以使用ping来探测。(不包括那些禁ping的网站) netstat 虽然ss命令可以替代netstat了,但现实中netstat仍然用的更广泛一些。比如,查看当前的所有tcp连接。 netstat -ant 此命令,在找一些本地起了什么端口之类的问题上,作用很大。 工作常用 还有一些在工作中经常会用到的命令,它们的出现频率是非常高的 ,都是些熟面孔。 export 很多安装了jdk的同学找不到java命令,export就可以帮你办到它。export用来设定一些环境变量,env命令能看到当前系统中所有的环境变量。比如,下面设置的就是jdk的。 export PATH=$PATH:/home/xjj/jdk/bin 有时候,你想要知道所执行命令的具体路径。那么就可以使用whereis命令,我是假定了你装了多个版本的jdk。 crontab 这就是linux本地的job工具。不是分布式的,你要不是运维,就不要用了。比如,每10分钟提醒喝茶上厕所。 */10 * * * * /home/xjj/wc10min date date命令用来输出当前的系统时间,可以使用-s参数指定输出格式。但设置时间涉及到设置硬件,所以有另外一个命令叫做hwclock。 xargs xargs读取输入源,然后逐行处理。这个命令非常有用。举个栗子,删除目录中的所有class文件。 find . | grep .class$ | xargs rm -rvf #把所有的rmvb文件拷贝到目录 ls *.rmvb | xargs -n1 -i cp {} /mount/xiaodianying 网络 linux是一个多作业的网络操作系统,所以网络命令有很多很多。工作中,最常和这些打交道。 ssh 这个,就不啰嗦了。你一定希望了解ssh隧道是什么。你要是想要详细的输出过程,记得加参数-v。 scp scp用来进行文件传输。也可以用来传输目录。也有更高级的sftp命令。 scp a.txt 192.168.0.12:/tmp/a.txt scp -r a_dir 192.168.0.12:/tmp/ wget 你想要在服务器上安装jdk,不会先在本地下载下来,然后使用scp传到服务器上吧(有时候不得不这样)。wget命令可以让你直接使用命令行下载文件,并支持断点续传。 wget -c http://oracle.fuck/jdk2019.bin mysql mysql应用广泛,并不是每个人都有条件用上navicat的。你需要了解mysql的连接方式和基本的操作,在异常情况下才能游刃有余。 mysql -u root -p -h 192.168.1.2

问问小秘 2020-04-01 10:52:50 0 浏览量 回答数 0

回答

重试作用: 对于重试是有场景限制的,不是什么场景都适合重试,比如参数校验不合法、写操作等(要考虑写是否幂等)都不适合重试。 远程调用超时、网络突然中断可以重试。在微服务治理框架中,通常都有自己的重试与超时配置,比如dubbo可以设置retries=1,timeout=500调用失败只重试1次,超过500ms调用仍未返回则调用失败。 比如外部 RPC 调用,或者数据入库等操作,如果一次操作失败,可以进行多次重试,提高调用成功的可能性。 优雅的重试机制要具备几点: 无侵入:这个好理解,不改动当前的业务逻辑,对于需要重试的地方,可以很简单的实现 可配置:包括重试次数,重试的间隔时间,是否使用异步方式等 通用性:最好是无改动(或者很小改动)的支持绝大部分的场景,拿过来直接可用 优雅重试共性和原理: 正常和重试优雅解耦,重试断言条件实例或逻辑异常实例是两者沟通的媒介。 约定重试间隔,差异性重试策略,设置重试超时时间,进一步保证重试有效性以及重试流程稳定性。 都使用了命令设计模式,通过委托重试对象完成相应的逻辑操作,同时内部封装实现重试逻辑。 Spring-tryer和guava-tryer工具都是线程安全的重试,能够支持并发业务场景的重试逻辑正确性。 优雅重试适用场景: 功能逻辑中存在不稳定依赖场景,需要使用重试获取预期结果或者尝试重新执行逻辑不立即结束。比如远程接口访问,数据加载访问,数据上传校验等等。 对于异常场景存在需要重试场景,同时希望把正常逻辑和重试逻辑解耦。 对于需要基于数据媒介交互,希望通过重试轮询检测执行逻辑场景也可以考虑重试方案。 优雅重试解决思路: 切面方式 这个思路比较清晰,在需要添加重试的方法上添加一个用于重试的自定义注解,然后在切面中实现重试的逻辑,主要的配置参数则根据注解中的选项来初始化 优点: 真正的无侵入 缺点: 某些方法无法被切面拦截的场景无法覆盖(如spring-aop无法切私有方法,final方法) 直接使用aspecj则有些小复杂;如果用spring-aop,则只能切被spring容器管理的bean 消息总线方式 这个也比较容易理解,在需要重试的方法中,发送一个消息,并将业务逻辑作为回调方法传入;由一个订阅了重试消息的consumer来执行重试的业务逻辑 优点: 重试机制不受任何限制,即在任何地方你都可以使用 利用EventBus框架,可以非常容易把框架搭起来 缺点: 业务侵入,需要在重试的业务处,主动发起一条重试消息 调试理解复杂(消息总线方式的最大优点和缺点,就是过于灵活了,你可能都不知道什么地方处理这个消息,特别是新的童鞋来维护这段代码时) 如果要获取返回结果,不太好处理, 上下文参数不好处理 模板方式 优点: 简单(依赖简单:引入一个类就可以了; 使用简单:实现抽象类,讲业务逻辑填充即可;) 灵活(这个是真正的灵活了,你想怎么干都可以,完全由你控制) 缺点: 强侵入 代码臃肿 把这个单独捞出来,主要是某些时候我就一两个地方要用到重试,简单的实现下就好了,也没有必用用到上面这么重的方式;而且我希望可以针对代码快进行重试 这个的设计还是非常简单的,基本上代码都可以直接贴出来,一目了然: 复制代码 public abstract class RetryTemplate { private static final int DEFAULT_RETRY_TIME = 1; private int retryTime = DEFAULT_RETRY_TIME; private int sleepTime = 0;// 重试的睡眠时间 public int getSleepTime() { return sleepTime; } public RetryTemplate setSleepTime(int sleepTime) { if(sleepTime < 0) { throw new IllegalArgumentException("sleepTime should equal or bigger than 0"); } this.sleepTime = sleepTime; return this; } public int getRetryTime() { return retryTime; } public RetryTemplate setRetryTime(int retryTime) { if (retryTime <= 0) { throw new IllegalArgumentException("retryTime should bigger than 0"); } this.retryTime = retryTime; return this; } /** * 重试的业务执行代码 * 失败时请抛出一个异常 * * todo 确定返回的封装类,根据返回结果的状态来判定是否需要重试 * * @return */ protected abstract Object doBiz() throws Exception; //预留一个doBiz方法由业务方来实现,在其中书写需要重试的业务代码,然后执行即可 public Object execute() throws InterruptedException { for (int i = 0; i < retryTime; i++) { try { return doBiz(); } catch (Exception e) { log.error("业务执行出现异常,e: {}", e); Thread.sleep(sleepTime); } } return null; } public Object submit(ExecutorService executorService) { if (executorService == null) { throw new IllegalArgumentException("please choose executorService!"); } return executorService.submit((Callable) () -> execute()); } } 复制代码 使用示例: 复制代码 public void retryDemo() throws InterruptedException { Object ans = new RetryTemplate() { @Override protected Object doBiz() throws Exception { int temp = (int) (Math.random() * 10); System.out.println(temp); if (temp > 3) { throw new Exception("generate value bigger then 3! need retry"); } return temp; } }.setRetryTime(10).setSleepTime(10).execute(); System.out.println(ans); } 复制代码 spring-retry Spring Retry 为 Spring 应用程序提供了声明性重试支持。 它用于Spring批处理、Spring集成、Apache Hadoop(等等)的Spring。 在分布式系统中,为了保证数据分布式事务的强一致性,在调用RPC接口或者发送MQ时,针对可能会出现网络抖动请求超时情况采取一下重试操作。 用的最多的重试方式就是MQ了,但是如果你的项目中没有引入MQ,就不方便了。 还有一种方式,是开发者自己编写重试机制,但是大多不够优雅。 缺陷 spring-retry 工具虽能优雅实现重试,但是存在两个不友好设计: 一个是重试实体限定为 Throwable 子类,说明重试针对的是可捕捉的功能异常为设计前提的,但是我们希望依赖某个数据对象实体作为重试实体, 但 sping-retry框架必须强制转换为Throwable子类。 另一个是重试根源的断言对象使用的是 doWithRetry 的 Exception 异常实例,不符合正常内部断言的返回设计。 Spring Retry 提倡以注解的方式对方法进行重试,重试逻辑是同步执行的,当抛出相关异常后执行重试, 如果你要以返回值的某个状态来判定是否需要重试,可能只能通过自己判断返回值然后显式抛出异常了。只读操作可以重试,幂等写操作可以重试,但是非幂等写操作不能重试,重试可能导致脏写,或产生重复数据。 @Recover 注解在使用时无法指定方法,如果一个类中多个重试方法,就会很麻烦。 spring-retry 结构 BackOff:补偿值,一般指失败后多久进行重试的延迟值。 Sleeper:暂停应用的工具,通常用来应用补偿值。 RetryState:重试状态,通常包含一个重试的键值。 RetryCallback:封装你需要重试的业务逻辑(上文中的doSth) RecoverCallback:封装了多次重试都失败后你需要执行的业务逻辑(上文中的doSthWhenStillFail) RetryContext:重试语境下的上下文,代表了能被重试动作使用的资源。可用于在多次Retry或者Retry 和Recover之间传递参数或状态(在多次doSth或者doSth与doSthWhenStillFail之间传递参数) RetryOperations: 定义了“重试”的模板(重试的API),要求传入RetryCallback,可选传入RecoveryCallback; RetryTemplate :RetryOperations的具体实现,组合了RetryListener[],BackOffPolicy,RetryPolicy。 RetryListener:用来监控Retry的执行情况,并生成统计信息。 RetryPolicy:重试的策略或条件,可以简单的进行多次重试,可以是指定超时时间进行重试(上文中的someCondition),决定失败能否重试。 BackOffPolicy: 重试的回退策略,在业务逻辑执行发生异常时。如果需要重试,我们可能需要等一段时间(可能服务器过于繁忙,如果一直不间隔重试可能拖垮服务器),当然这段时间可以是0,也可以是固定的,可以是随机的(参见tcp的拥塞控制算法中的回退策略)。回退策略在上文中体现为wait(); RetryPolicy提供了如下策略实现: NeverRetryPolicy:只允许调用RetryCallback一次,不允许重试; AlwaysRetryPolicy:允许无限重试,直到成功,此方式逻辑不当会导致死循环; SimpleRetryPolicy:固定次数重试策略,默认重试最大次数为3次,RetryTemplate默认使用的策略; TimeoutRetryPolicy:超时时间重试策略,默认超时时间为1秒,在指定的超时时间内允许重试; CircuitBreakerRetryPolicy:有熔断功能的重试策略,需设置3个参数openTimeout、resetTimeout和delegate delegate:是真正判断是否重试的策略,当重试失败时,则执行熔断策略;应该配置基于次数的SimpleRetryPolicy或者基于超时的TimeoutRetryPolicy策略,且策略都是全局模式,而非局部模式,所以要注意次数或超时的配置合理性。 openTimeout:openWindow,配置熔断器电路打开的超时时间,当超过openTimeout之后熔断器电路变成半打开状态(主要有一次重试成功,则闭合电路); resetTimeout:timeout,配置重置熔断器重新闭合的超时时间 CompositeRetryPolicy:组合重试策略,有两种组合方式,乐观组合重试策略是指只要有一个策略允许重试即可以,悲观组合重试策略是指只要有一个策略不允许重试即可以,但不管哪种组合方式,组合中的每一个策略都会执行。 BackOffPolicy 提供了如下策略实现: NoBackOffPolicy:无退避算法策略,即当重试时是立即重试; FixedBackOffPolicy:固定时间的退避策略,需设置参数sleeper(指定等待策略,默认是Thread.sleep,即线程休眠)、backOffPeriod(休眠时间,默认1秒); UniformRandomBackOffPolicy:随机时间退避策略,需设置sleeper、minBackOffPeriod、maxBackOffPeriod,该策略在[minBackOffPeriod,maxBackOffPeriod之间取一个随机休眠时间,minBackOffPeriod默认500毫秒,maxBackOffPeriod默认1500毫秒; ExponentialBackOffPolicy:指数退避策略,需设置参数sleeper、initialInterval、maxInterval和multiplier。initialInterval指定初始休眠时间,默认100毫秒,maxInterval指定最大休眠时间,默认30秒,multiplier指定乘数,即下一次休眠时间为当前休眠时间*multiplier; ExponentialRandomBackOffPolicy:随机指数退避策略,引入随机乘数,固定乘数可能会引起很多服务同时重试导致DDos,使用随机休眠时间来避免这种情况。 RetryTemplate主要流程实现: 复制代码 //示例一 public void upload(final Map<String, Object> map) throws Exception { // 构建重试模板实例 RetryTemplate retryTemplate = new RetryTemplate(); // 设置重试策略,主要设置重试次数 SimpleRetryPolicy policy =         new SimpleRetryPolicy(3, Collections.<Class<? extends Throwable>, Boolean> singletonMap(Exception.class, true)); // 设置重试回退操作策略,主要设置重试间隔时间 FixedBackOffPolicy fixedBackOffPolicy = new FixedBackOffPolicy(); fixedBackOffPolicy.setBackOffPeriod(100); retryTemplate.setRetryPolicy(policy); retryTemplate.setBackOffPolicy(fixedBackOffPolicy); // 通过RetryCallback 重试回调实例包装正常逻辑逻辑,第一次执行和重试执行执行的都是这段逻辑 final RetryCallback<Object, Exception> retryCallback = new RetryCallback<Object, Exception>() { //RetryContext 重试操作上下文约定,统一spring-try包装 public Object doWithRetry(RetryContext context) throws Exception { System.out.println("do some thing"); Exception e = uploadToOdps(map); System.out.println(context.getRetryCount()); throw e;//这个点特别注意,重试的根源通过Exception返回 } }; // 通过RecoveryCallback 重试流程正常结束或者达到重试上限后的退出恢复操作实例 final RecoveryCallback recoveryCallback = new RecoveryCallback() { public Object recover(RetryContext context) throws Exception { System.out.println("do recory operation"); return null; } }; try { // 由retryTemplate 执行execute方法开始逻辑执行 retryTemplate.execute(retryCallback, recoveryCallback); } catch (Exception e) { e.printStackTrace(); } } //示例二 protected <T, E extends Throwable> T doExecute(RetryCallback<T, E> retryCallback,RecoveryCallback recoveryCallback,   RetryState state) throws E, ExhaustedRetryException { //重试策略 RetryPolicy retryPolicy = this.retryPolicy; //退避策略 BackOffPolicy backOffPolicy = this.backOffPolicy; //重试上下文,当前重试次数等都记录在上下文中 RetryContext context = open(retryPolicy, state); try { //拦截器模式,执行RetryListener#open boolean running = doOpenInterceptors(retryCallback, context); //判断是否可以重试执行 while (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) { try {//执行RetryCallback回调 return retryCallback.doWithRetry(context); } catch (Throwable e) {//异常时,要进行下一次重试准备 //遇到异常后,注册该异常的失败次数 registerThrowable(retryPolicy, state, context, e); //执行RetryListener#onError doOnErrorInterceptors(retryCallback, context, e); //如果可以重试,执行退避算法,比如休眠一小段时间后再重试 if (canRetry(retryPolicy, context) && !context.isExhaustedOnly()) { backOffPolicy.backOff(backOffContext); } //state != null && state.rollbackFor(context.getLastThrowable()) //在有状态重试时,如果是需要执行回滚操作的异常,则立即抛出异常 if (shouldRethrow(retryPolicy, context, state)) { throw RetryTemplate. wrapIfNecessary(e); } } //如果是有状态重试,且有GLOBAL_STATE属性,则立即跳出重试终止;       //当抛出的异常是非需要执行回滚操作的异常时,才会执行到此处,CircuitBreakerRetryPolicy会在此跳出循环; if (state != null && context.hasAttribute(GLOBAL_STATE)) { break; } } //重试失败后,如果有RecoveryCallback,则执行此回调,否则抛出异常 return handleRetryExhausted(recoveryCallback, context, state); } catch (Throwable e) { throw RetryTemplate. wrapIfNecessary(e); } finally { //清理环境 close(retryPolicy, context, state, lastException == null || exhausted); //执行RetryListener#close,比如统计重试信息 doCloseInterceptors(retryCallback, context, lastException); } } 复制代码 有状态or无状态 无状态重试,是在一个循环中执行完重试策略,即重试上下文保持在一个线程上下文中,在一次调用中进行完整的重试策略判断。如远程调用某个查询方法时是最常见的无状态重试: 复制代码 RetryTemplate template = new RetryTemplate(); //重试策略:次数重试策略 RetryPolicy retryPolicy = new SimpleRetryPolicy(3); template.setRetryPolicy(retryPolicy); //退避策略:指数退避策略 ExponentialBackOffPolicy backOffPolicy = new ExponentialBackOffPolicy(); backOffPolicy.setInitialInterval(100); backOffPolicy.setMaxInterval(3000); backOffPolicy.setMultiplier(2); backOffPolicy.setSleeper(new ThreadWaitSleeper()); template.setBackOffPolicy(backOffPolicy); //当重试失败后,抛出异常 String result = template.execute(new RetryCallback<String, RuntimeException>() { @Override public String doWithRetry(RetryContext context) throws RuntimeException { throw new RuntimeException("timeout"); } }); //当重试失败后,执行RecoveryCallback String result = template.execute(new RetryCallback<String, RuntimeException>() { @Override public String doWithRetry(RetryContext context) throws RuntimeException { System.out.println("retry count:" + context.getRetryCount()); throw new RuntimeException("timeout"); } }, new RecoveryCallback () { @Override public String recover(RetryContext context) throws Exception { return "default"; } }); 复制代码 有状态重试,有两种情况需要使用有状态重试,事务操作需要回滚、熔断器模式。 事务操作需要回滚场景时,当整个操作中抛出的是数据库异常DataAccessException,则不能进行重试需要回滚,而抛出其他异常则可以进行重试,可以通过RetryState实现: 复制代码 //当前状态的名称,当把状态放入缓存时,通过该key查询获取 Object key = "mykey"; //是否每次都重新生成上下文还是从缓存中查询,即全局模式(如熔断器策略时从缓存中查询) boolean isForceRefresh = true; //对DataAccessException进行回滚 BinaryExceptionClassifier rollbackClassifier = new BinaryExceptionClassifier(Collections.<Class<? extends Throwable>>singleton(DataAccessException.class)); RetryState state = new DefaultRetryState(key, isForceRefresh, rollbackClassifier); String result = template.execute(new RetryCallback<String, RuntimeException>() { @Override public String doWithRetry(RetryContext context) throws RuntimeException { System.out.println("retry count:" + context.getRetryCount()); throw new TypeMismatchDataAccessException(""); } }, new RecoveryCallback () { @Override public String recover(RetryContext context) throws Exception { return "default"; } }, state); 复制代码 RetryTemplate中在有状态重试时,回滚场景时直接抛出异常处理代码: //state != null && state.rollbackFor(context.getLastThrowable()) //在有状态重试时,如果是需要执行回滚操作的异常,则立即抛出异常 if (shouldRethrow(retryPolicy,context, state)) { throw RetryTemplate. wrapIfNecessary(e); } 熔断器场景。在有状态重试时,且是全局模式,不在当前循环中处理重试,而是全局重试模式(不是线程上下文),如熔断器策略时测试代码如下所示。 复制代码 RetryTemplate template = new RetryTemplate(); CircuitBreakerRetryPolicy retryPolicy = new CircuitBreakerRetryPolicy(new SimpleRetryPolicy(3)); retryPolicy.setOpenTimeout(5000); retryPolicy.setResetTimeout(20000); template.setRetryPolicy(retryPolicy); for (int i = 0; i < 10; i++) { try { Object key = "circuit"; boolean isForceRefresh = false; RetryState state = new DefaultRetryState(key, isForceRefresh); String result = template.execute(new RetryCallback<String, RuntimeException>() { @Override public String doWithRetry(RetryContext context) throws RuntimeException { System.out.println("retry count:" + context.getRetryCount()); throw new RuntimeException("timeout"); } }, new RecoveryCallback () { @Override public String recover(RetryContext context) throws Exception { return "default"; } }, state); System.out.println(result); } catch (Exception e) { System.out.println(e); } } 复制代码 为什么说是全局模式呢?我们配置了isForceRefresh为false,则在获取上下文时是根据key “circuit”从缓存中获取,从而拿到同一个上下文。 Object key = "circuit"; boolean isForceRefresh = false; RetryState state = new DefaultRetryState(key,isForceRefresh); 如下RetryTemplate代码说明在有状态模式下,不会在循环中进行重试。 if (state != null && context.hasAttribute(GLOBAL_STATE)) { break; } 判断熔断器电路是否打开的代码: 复制代码 public boolean isOpen() { long time = System.currentTimeMillis() - this.start; boolean retryable = this.policy.canRetry(this.context); if (!retryable) {//重试失败 //在重置熔断器超时后,熔断器器电路闭合,重置上下文 if (time > this.timeout) { this.context = createDelegateContext(policy, getParent()); this.start = System.currentTimeMillis(); retryable = this.policy.canRetry(this.context); } else if (time < this.openWindow) { //当在熔断器打开状态时,熔断器电路打开,立即熔断 if ((Boolean) getAttribute(CIRCUIT_OPEN) == false) { setAttribute(CIRCUIT_OPEN, true); } this.start = System.currentTimeMillis(); return true; } } else {//重试成功 //在熔断器电路半打开状态时,断路器电路闭合,重置上下文 if (time > this.openWindow) { this.start = System.currentTimeMillis(); this.context = createDelegateContext(policy, getParent()); } } setAttribute(CIRCUIT_OPEN, !retryable); return !retryable; } 复制代码 从如上代码可看出spring-retry的熔断策略相对简单: 当重试失败,且在熔断器打开时间窗口[0,openWindow) 内,立即熔断; 当重试失败,且在指定超时时间后(>timeout),熔断器电路重新闭合; 在熔断器半打开状态[openWindow, timeout] 时,只要重试成功则重置上下文,断路器闭合。 注解介绍 @EnableRetry 表示是否开始重试。 序号 属性 类型 默认值 说明 1 proxyTargetClass boolean false 指示是否要创建基于子类的(CGLIB)代理,而不是创建标准的基于Java接口的代理。当proxyTargetClass属性为true时,使用CGLIB代理。默认使用标准JAVA注解 @Retryable 标注此注解的方法在发生异常时会进行重试 序号 属性 类型 默认值 说明 1 interceptor String ”” 将 interceptor 的 bean 名称应用到 retryable() 2 value class[] {} 可重试的异常类型 3 include class[] {} 和value一样,默认空,当exclude也为空时,所有异常都重试 4 exclude class[] {} 指定异常不重试,默认空,当include也为空时,所有异常都重试 5 label String ”” 统计报告的唯一标签。如果没有提供,调用者可以选择忽略它,或者提供默认值。 6 maxAttempts int 3 尝试的最大次数(包括第一次失败),默认为3次。 7 backoff @Backoff @Backoff() 重试补偿机制,指定用于重试此操作的backoff属性。默认为空 @Backoff 不设置参数时,默认使用FixedBackOffPolicy(指定等待时间),重试等待1000ms 序号 属性 类型 默认值 说明 1 delay long 0 指定延迟后重试 ,如果不设置则默认使用 1000 milliseconds 2 maxDelay long 0 最大重试等待时间 3 multiplier long 0 指定延迟的倍数,比如delay=5000l,multiplier=2时,第一次重试为5秒后,第二次为10秒,第三次为20秒(大于0生效) 4 random boolean false 随机重试等待时间 @Recover 用于恢复处理程序的方法调用的注释。返回类型必须与@retryable方法匹配。 可抛出的第一个参数是可选的(但是没有它的方法只会被调用)。 从失败方法的参数列表按顺序填充后续的参数。 用于@Retryable重试失败后处理方法,此注解注释的方法参数一定要是@Retryable抛出的异常,否则无法识别,可以在该方法中进行日志处理。 说明: 使用了@Retryable的方法不能在本类被调用,不然重试机制不会生效。也就是要标记为@Service,然后在其它类使用@Autowired注入或者@Bean去实例才能生效。 要触发@Recover方法,那么在@Retryable方法上不能有返回值,只能是void才能生效。 使用了@Retryable的方法里面不能使用try...catch包裹,要在发放上抛出异常,不然不会触发。 在重试期间这个方法是同步的,如果使用类似Spring Cloud这种框架的熔断机制时,可以结合重试机制来重试后返回结果。 Spring Retry不只能注入方式去实现,还可以通过API的方式实现,类似熔断处理的机制就基于API方式实现会比较宽松。 转载于:https://www.cnblogs.com/whatarewords/p/10656514.html

养狐狸的猫 2019-12-02 02:11:54 0 浏览量 回答数 0
阿里云大学 云服务器ECS com域名 网站域名whois查询 开发者平台 小程序定制 小程序开发 国内短信套餐包 开发者技术与产品 云数据库 图像识别 开发者问答 阿里云建站 阿里云备案 云市场 万网 阿里云帮助文档 免费套餐 开发者工具 企业信息查询 小程序开发制作 视频内容分析 企业网站制作 视频集锦 代理记账服务 2020阿里巴巴研发效能峰会 企业建站模板 云效成长地图 高端建站