在本文中，我们将详细介绍存储NAB2019:Infortrend赢得VideoEdge颁发的Future最佳表现奖的各个方面，并为您提供关于存储zb的相关解答，同时，我们也将为您带来关于2019-05

在本文中，我们将详细介绍存储 NAB 2019: Infortrend赢得Video Edge颁发的Future最佳表现奖的各个方面，并为您提供关于存储zb的相关解答，同时，我们也将为您带来关于2019-05-17 ABRT has detected 1 problem(s). For more info run: abrt-cli list --since 1558053651、20190620_二次开发 BarTender 打印机时，未能解析主引用 “Seagull.BarTender.Print, Version=1.0.0.0, Culture=neutral, pro...、android – GestureOverlayView和GestureDetector的性能、Android 并发编程之白话文详解 Future,FutureTask 和 Callable的有用知识。

本文目录一览：

• 存储 NAB 2019: Infortrend赢得Video Edge颁发的Future最佳表现奖（存储zb）
• 2019-05-17 ABRT has detected 1 problem(s). For more info run: abrt-cli list --since 1558053651
• 20190620_二次开发 BarTender 打印机时，未能解析主引用 “Seagull.BarTender.Print, Version=1.0.0.0, Culture=neutral, pro...
• android – GestureOverlayView和GestureDetector的性能
• Android 并发编程之白话文详解 Future,FutureTask 和 Callable

存储 NAB 2019: Infortrend赢得Video Edge颁发的Future最佳表现奖（存储zb）

2019-05-17 ABRT has detected 1 problem(s). For more info run: abrt-cli list --since 1558053651

看了一博客  让我比较汗颜 因为我现在总是遇到问题 就是百度

好像已经变成我唯一解决问题的方式了

下图摘自一博客链接：https://blog.51cto.com/it3246/1889635

 看了后有些感悟 与大家共勉下 

下面开始解释问题

命令 1：abrt-cli list --since 1558053651 

可以看到引起这个问题的原因了  

意思大概可以看出是 系统出现一个 bug，什么 软件 lockup (死锁)  CPU 在这个压力下 29 秒后 崩溃了 哈哈  个人解释哈，

其他解释是 

#内核软死锁（soft lockup）bug

Soft lockup 名称解释：所谓，soft lockup 就是说，这个 bug 没有让系统彻底死机，但是若干个进程（或者 kernel thread）被锁死在了某个状态（一般在内核区域），很多情况下这个是由于内核锁的使用的问题。

解决方案：

[root@git-node1 data]# tail -1 /proc/sys/kernel/watchdog_thresh
30

#临时生效

sysctl -w kernel.watchdog_thresh=30

#永久配置：

命令：vi /etc/sysctl.conf

最后一行添加：kernel.watchdog_thresh=30

就 OK 了！

20190620_二次开发 BarTender 打印机时，未能解析主引用 “Seagull.BarTender.Print, Version=1.0.0.0, Culture=neutral, pro...

错误提示:

严重性 代码 说明 项目 文件 行 禁止显示状态
警告 未能解析主引用 “Seagull.BarTender.Print, Version=1.0.0.0, Culture=neutral, processorArchitecture=x86”，因为它对框架程序集 “System.IdentityModel.Selectors, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089” 有间接依赖关系，而在当前目标框架中未能解析该程序集。“.NETFramework,Version=v2.0”。若要解决此问题，请移除引用 “Seagull.BarTender.Print, Version=1.0.0.0, Culture=neutral, processorArchitecture=x86”，或将应用程序的目标重新指向包含 “System.IdentityModel.Selectors, Version=3.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089” 的框架版本。 

 

解决办法:

将.net Framework 调到 4.0

然后接下来有另一个报错:

转到配置文件，加上

参见:

https://docs.microsoft.com/zh-cn/dotnet/framework/configure-apps/file-schema/startup/startup-element

 

android – GestureOverlayView和GestureDetector的性能

Android 并发编程之白话文详解 Future,FutureTask 和 Callable

从最简单的说起 Thread 和 Runnable

说到并发编程，就一定是多个线程并发执行任务。那么并发编程的基础是什么呢？没错那就是 Thread 了。一个 Thread 可以执行一个 Runnable 类型的对象。那么 Runnable 是什么呢？其实 Runnable 是一个接口，他只定义了一个方法 run（），这个 run（）方法里就是我们要执行的任务，并且是要被 Thread 调用的。因此，一个 Runnable 就可以理解为一个要被执行的任务，而 Thread 就是一个执行任务的工人！
接下来我们用一个例子来实践一下，我们有一个任务（Runnable），这个任务就是来计算 1+2+3+…+10，然后我们叫来一个工人（Thread）来执行这个任务。

public class ThreadDemo {
    public static void main(String[] args) { Thread worker = new Thread(new CountRunnable()); worker.start(); } public static class CountRunnable implements Runnable{ private int sum; @Override public void run() { for(int i=1 ; i<11 ; i++){ sum = sum+i; } System.out.println("sum="+sum); } } }

这里我们调用了 Thread 的 start () 方法，相当于通知我们的工人去干活，然后工人 Thread 去调用任务 Runnable 的 run（）方法去干活。

如果我们觉得一个工人不够用，那么我们可以多叫来几个工人，让他们一起来工作，这就是并发编程了！

public class ThreadDemo {
    public static void main(String[] args) throws Exception{ List<Thread> threads = new ArrayList<Thread>(); for(int i=1 ; i<101 ; i++){ Thread thread = new Thread(new CountRunnable(),"Thread"+i); threads.add(thread); thread.start(); } for(Thread t : threads){ t.join(); } System.out.println("所有线程执行完毕！"); } public static class CountRunnable implements Runnable{ private int sum; @Override public void run() { for(int i=1 ; i<11 ; i++){ sum = sum+i; } System.out.println(Thread.currentThread().getName()+"执行完毕 sum="+sum); } } }

我们看到，每个 sum 都等于 55，不是听说多线程并发执行会带来线程不安全的问题吗？其实这里我们是给每个工人分配一个只属于自己的任务，每个工人干自己的活，所以并不会影响到其他的人

Thread thread = new Thread(new CountRunnable(),"Thread"+i);

• 1

那么什么情况下会出现线程并发的问题的？我们要做的就是把一个任务同时分配给 100 名工人，那么就会出现线程不安全的问题

public class ThreadDemo {
    public static void main(String[] args) throws Exception{ List<Thread> threads = new ArrayList<Thread>(); //注意这里，我们在外面new出一个任务来，让100个线程都来执行这个任务 CountRunnable work = new CountRunnable(); for(int i=1 ; i<101; i++){ Thread thread = new Thread(work,"Thread"+i); threads.add(thread); } for(Thread t : threads){ t.start(); } for(Thread t : threads){ t.join(); } System.out.println("所有线程执行完毕"); } public static class CountRunnable implements Runnable{ private int sum; @Override public void run() { for(int i=1 ; i<11 ; i++){ try { //在这里我们让每个工人每进行一次加法运算后就休息1ms，这样会使得结果明显 TimeUnit.MILLISECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } sum = sum+i; } System.out.println(Thread.currentThread().getName()+"执行完毕 sum="+sum); } } } 

我们看到的结果简直不堪入目，正确结果应该是 5500 对吧，这时因为我们有 100 名工人去干一件任务，他们都操作的是同一个变量，因此多线程修改共享变量会出现问题，至于原理是什么，大家可以参考我的另一篇文章 Java 并发编程之图文解析 volatile 关键字来了解一下 Java 的内存模型（JMM）。

这篇文章的题目不是叫 Future，FutureTask 和 Callable 吗？我怎么连他们的影子都还没有见到？大家先别着急，还是和我一起慢慢深入，这样才能真正理解他们存在的道理。

最简单的方法出现了问题，线程池来解决

现在我们可以叫来这 100 名工人来为我们干活了，可是这样有个问题，这 100 名工人不是说找就找的，首先你得去发招聘启事，接着再去面试，再去培训等等，非常的费时费力，所以我们应该找到一个外包公司，比如我们需要 100 名工人，我们直接就到外包公司去借 100 名工人，直接来干活，这样就省了不少的力气了，这个外包公司就是线程池了。关于线程池的介绍，有一篇写的非常详细的博客 Android 性能优化之使用线程池处理异步任务，既然已经有人把它的理论总结的很清晰透彻了，我就不再重复去介绍一遍了，如果大家有对线程池的基础还不了解的话，推荐看看这篇文章。下面我就来说说线程池的使用，慢慢引出 Future 和 Callable。

我们在使用线程池的时候，可以把一个任务（Runnable）交给线程池，调用线程池的 execute (runnable) 来执行

public class ExecutorDemo {
    public static void main(String[] args) { ExecutorService es = Executors.newSingleThreadExecutor(); CountRunnable work = new CountRunnable(); es.execute(work); es.shutdown(); System.out.println("任务结束"+es.isShutdown()); } public static class CountRunnable implements Runnable{ private int sum; @Override public void run() { for(int i=1 ; i<11 ; i++){ sum+=i; } System.out.println("sum="+sum); } } }

不知道大家有没有发现一个问题，我们执行 Runnable 任务，他的 run（）方法是没有返回值的，那如果我们想要执行完一个任务，并且能够拿到一个返回值结果，那么应该怎么做呢？

Future 登场

当当当！没错！主角就要登场了！首先介绍 Future

public interface Future<V> {


    boolean cancel(boolean mayInterruptIfRunning);


    boolean isCancelled();


    boolean isDone();


    V get() throws InterruptedException, ExecutionException;


    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; } 

Future 是一个接口，他提供给了我们方法来检测当前的任务是否已经结束，还可以等待任务结束并且拿到一个结果，通过调用 Future 的 get（）方法可以当任务结束后返回一个结果值，如果工作没有结束，则会阻塞当前线程，直到任务执行完毕，我们可以通过调用 cancel（）方法来停止一个任务，如果任务已经停止，则 cancel（）方法会返回 true；如果任务已经完成或者已经停止了或者这个任务无法停止，则 cancel（）会返回一个 false。当一个任务被成功停止后，他无法再次执行。isDone（）和 isCancel（）方法可以判断当前工作是否完成和是否取消。

简单介绍一番，我们发现原来那些工人，只会去执行工作，做完工作之后也不给我们反馈信息，并且我们也不知道他们何时能完工，更不能打断他们的工作，这种工人的弊端就显现出来了。

现在我们有了更高级的工人，这些工人只能是从外包公司来借（利用线程池），当这些工人干完活之后，他们会给我们返回运行的结果，而且我们还可以暂停他们的工作。

我们看到线程池还有一个方法可以执行一个任务，那就是 submit（）方法

 public Future<?> submit(Runnable task) {
            return e.submit(task);
        }

我们看到他会返回一个 Future 对象，这个 Future 对象的泛型里还用的是一个问号 “？”，问号就是说我们不知道要返回的对象是什么类型，那么就返回一个 null 好了，因为我们执行的是一个 Runnable 对象，Runnable 是没有返回值的，所以这里用一个问号，说明没有返回值，那么就返回一个 null 好了。

public class ExecutorDemo {
    public static void main(String[] args) { ExecutorService es = Executors.newSingleThreadExecutor(); CountRunnable work = new CountRunnable(); Future<?> future = es.submit(work); System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); for(int i=0 ; i<10 ; i++){ try { TimeUnit.SECONDS.sleep(1); System.out.println("主线程"+Thread.currentThread().getName()+"仍然可以执行"); } catch (InterruptedException e) { e.printStackTrace(); } } try { Object object = future.get(); System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+" result="+object); } catch (Exception e) { e.printStackTrace(); } es.shutdown(); System.out.println("关闭线程池"+es.isShutdown()); } public static class CountRunnable implements Runnable{ private int sum; @Override public void run() { for(int i=1 ; i<11 ; i++){ try { TimeUnit.MILLISECONDS.sleep(1000); sum+=i; System.out.println("工作线程"+Thread.currentThread().getName()+"正在执行 sum="+sum); } catch (InterruptedException e) { e.printStackTrace(); } } } } }

 

我们看到 Future 有一个 get（）方法，这个方法是一个阻塞方法，我们调用 submit（）执行一个任务的时候，会执行 Runnable 中的 run（）方法，当 run（）方法没有执行完的时候，这个工人就会歇着了，直到 run（）方法执行结束后，工人就会立即将结果取回并且交给我们。我们看到返回的 result=null。那既然返回 null 的话还有什么意义呢？？别着急，那就要用到 Callable 接口了

Callable 登场

public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */ V call() throws Exception; }

我们看到 Callable 接口和 Runnable 接口很像，也是只有一个方法，不过这个 call（）方法是有返回值的，这个返回值是一个泛型，也就是说我们可以根据我们的需求来指定我们要返回的 result 的类型

public class CallableDemo {
    public static void main(String[] args) throws Exception{ ExecutorService es = Executors.newSingleThreadExecutor(); Future<Number> future = es.submit(new CountCallable()); System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); Number number = future.get(); System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); if(future.isDone()){ System.out.println("任务执行完毕 result="+number.num); es.shutdown(); } } public static class CountCallable implements Callable<Number>{ @Override public Number call() throws Exception { Number number = new Number(); TimeUnit.SECONDS.sleep(2); number.setNum(10); return number; } } static class Number{ private int num; private int getNum(){ return num; } private void setNum(int num){ this.num = num; } } }

我们创建我们的任务（Callable）的时候，传入了一个 Number 类的泛型，那么在 call（）方法中就会返回这个 Number 类型的对象，最后在 Future 的 get（）方法中就会返回我们的 Number 类型的结果。

然而 Future 不仅仅可以获得一个结果，他还可以被取消，我们通过调用 future 的 cancel（）方法，可以取消一个 Future 的执行

public class CallableDemo {
    public static void main(String[] args) throws Exception{ ExecutorService es = Executors.newSingleThreadExecutor(); Future<Number> future = es.submit(new CountCallable()); System.out.println("任务开始于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); } future.cancel(true); if (future.isCancelled()) { System.out.println("任务被取消于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); es.shutdownNow(); }else{ Number number = future.get(); System.out.println("任务结束于"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())); if(future.isDone()){ System.out.println("任务执行完毕 result="+number.num); es.shutdown(); } } } public static class CountCallable implements Callable<Number>{ @Override public Number call() throws Exception { Number number = new Number(); TimeUnit.SECONDS.sleep(5); number.setNum(10); return number; } } static class Number{ private int num; private int getNum(){ return num; } private void setNum(int num){ this.num = num; } } } 

FutureTask 登场

说完了 Future 和 Callable，我们再来说最后一个 FutureTask，Future 是一个接口，他的唯一实现类就是 FutureTask，其实 FutureTask 的一个很好地特点是他有一个回调函数 done（）方法，当一个任务执行结束后，会回调这个 done（）方法，我们可以在 done（）方法中调用 FutureTask 的 get（）方法来获得计算的结果。为什么我们要在 done（）方法中去调用 get（）方法呢？ 这是有原因的，我在 Android 开发中，如果我在主线程去调用 futureTask.get () 方法时，会阻塞我的 UI 线程，如果在 done（）方法里调用 get（），则不会阻塞我们的 UI 线程。

public class FutureTask<V> implements RunnableFuture<V> { }

我们来看看 FutureTask 实现了 RunnableFuture 接口

public interface RunnableFuture<V> extends Runnable, Future<V> { /** * Sets this Future to the result of its computation * unless it has been cancelled. */ void run(); }

 

Runnable 接口又实现了 Runnable 和 Future 接口，所以说 FutureTask 可以交给 Executor 执行，也可以由调用线程直接执行 FutureTask.run（）方法。FutureTask 的 run（）方法中又会调用 Callable 的 call（）方法

public void run() {
        if (state != NEW ||
            !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread())) return; try { Callable<V> c = callable; if (c != null && state == NEW) { V result; boolean ran; try { result = c.call(); ran = true; } catch (Throwable ex) { result = null; ran = false; setException(ex); } if (ran) set(result); } } finally { // runner must be non-null until state is settled to // prevent concurrent calls to run() runner = null; // state must be re-read after nulling runner to prevent // leaked interrupts int s = state; if (s >= INTERRUPTING) handlePossibleCancellationInterrupt(s); } }

所以一个 FutureTask 实际上执行的是一个 Callable 类型实例的 call（）方法，call () 方法才是我们的最终任务。其实 Android 中的 AsyncTask 内部也是使用的 FutureTask，我们写一个小的例子来模仿 AsyncTask 的可以停止的功能

public class MainActivity extends AppCompatActivity { FutureTask<Number> futureTask; CountCallable countCallable; ExecutorService es; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); countCallable = new CountCallable(); futureTask = new FutureTask<Number>(countCallable){ @Override protected void done() { try { Number number = futureTask.get(); Log.i("zhangqi", "任务结束于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date()) + " result=" + number.getNum()); } catch (InterruptedException e) { e.printStackTrace(); } catch (ExecutionException e) { e.printStackTrace(); } catch (CancellationException e) { Log.i("zhangqi", "任务被取消于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date())); } } }; es = Executors.newFixedThreadPool(2); es.execute(futureTask); Log.i("zhangqi", "任务被开始于" + new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(new Date())); } public void cancel(View view) { futureTask.cancel(true); } public static class CountCallable implements Callable<Number> { @Override public Number call() throws Exception { Number number = new Number(); Log.i("zhangqi","运行在"+Thread.currentThread().getName()); Thread.sleep(5000); number.setNum(10); return number; } } static class Number { private int num; private int getNum() { return num; } private void setNum(int num) { this.num = num; } } }

我们写了一个 CountCallable 类，在 call（）方法里是我们要执行的任务，最终我们的任务要返回一个 Number 类型的对象，我们在 call（）方法中首先会让线程睡眠 5 秒钟，然后 new 出一个 Number 对象并且给他赋值为 10.

接着我们 new 一个 FutureTask 并且把我们的 CountCallable 对象传入进去，FutureTask 的泛型就是我们要返回的结果的类型，并且我们要重写 FutureTask 的 done（）方法，这个方法会在任务结束后自动执行，在 done（）方法中我们调用 get（）方法获得运行的结果

现在我们执行 cancel 方法，来结束这个 FutureTask 任务


在任务执行 2 秒的时候，我点击了 cancel 按钮，执行了 FutureTask 的 cancel 方法，当我们执行了 cancel（）方法后，FutureTask 的 get（）方法会抛出 CancellationException 异常，我们捕捉这个异常，然后在这里来处理一些后事 =-=！

相信大家都已经理解了为什么 Java 要提供给我们 Future，FutureTask 和 Callable 了，他们其实是并发编程中更高级的应用，我们应该理解他们并且正确的使用它们。

--------------------- 本文来自 阿拉灯神灯 的 CSDN 博客 ，全文地址请点击：https://blog.csdn.net/nugongahou110/article/details/49967495?utm_source=copy

我们今天的关于存储 NAB 2019: Infortrend赢得Video Edge颁发的Future最佳表现奖和存储zb的分享已经告一段落，感谢您的关注，如果您想了解更多关于2019-05-17 ABRT has detected 1 problem(s). For more info run: abrt-cli list --since 1558053651、20190620_二次开发 BarTender 打印机时，未能解析主引用 “Seagull.BarTender.Print, Version=1.0.0.0, Culture=neutral, pro...、android – GestureOverlayView和GestureDetector的性能、Android 并发编程之白话文详解 Future,FutureTask 和 Callable的相关信息，请在本站查询。

本文标签：

• Infortrend
• Video_Edge
• Future_best_performance_award
• Storage_solution