程序博客网 > 跑步机推荐 知乎

积累线程实例

来源：互联网 发布：跑步机推荐 知乎 编辑：程序博客网 时间：2024/05/17 06:29
    JDK6 已经发布了，而对于JDK5 的新特性还来不及使用，虽然在项目中还没有使用，但可以写一些Demo体验一下Tiger的魅力，现在的时代就是体验的时代，事事都要亲历亲为才能有发言权，怎么有点毛主席“实事求是”的感觉。

JDK5中的一个亮点就是将Doug Lea 的并发库 引入到Java标准库中。Doug Lea确实是一个牛人，能教书，能出书，能编码，不过这在国外还是比较普遍的，而国内的教授们就相差太远了。

一般的服务器都需要线程池，比如Web、FTP等服务器，不过它们一般都自己实现了线程池，比如以前介绍过的Tomcat 、Resin和Jetty等，现在有了JDK5，我们就没有必要重复造车轮了，直接使用就可以，何况使用也很方便，性能也非常高。

Java代码 复制代码
  1. package concurrent;   
  2. import java.util.concurrent.ExecutorService;   
  3. import java.util.concurrent.Executors;   
  4. public class TestThreadPool {   
  5.   public static void main(String args[]) throws InterruptedException {   
  6.     // only two threads   
  7.     ExecutorService exec = Executors.newFixedThreadPool(2);   
  8.     for(int index = 0; index < 100; index++) {   
  9.       Runnable run = new Runnable() {   
  10.         public void run() {   
  11.           long time = (long) (Math.random() * 1000);   
  12.           System.out.println("Sleeping " + time + "ms");   
  13.             try {   
  14.               Thread.sleep(time);   
  15.             } catch (InterruptedException e) {   
  16.             }   
  17.         }   
  18.       };   
  19.       exec.execute(run);   
  20.     }   
  21.     // must shutdown   
  22.     exec.shutdown();   
  23.   }   
  24. }  
 

    上面是一个简单的例子，使用了2个大小的线程池来处理100个线程。但有一个问题：在for循环的过程中，会等待线程池有空闲的线程，所以主线程会阻塞的。为了解决这个问题，一般启动一个线程来做for循环，就是为了避免由于线程池满了造成主线程阻塞。不过在这里我没有这样处理。[重要修正：经过测试，即使线程池大小小于实际线程数大小，线程池也不会阻塞的，这与Tomcat的线程池不同，它将Runnable实例放到一个“无限”的 BlockingQueue中，所以就不用一个线程启动for循环，Doug Lea果然厉害]

另外它使用了Executors的静态函数生成一个固定的线程池，顾名思义，线程池的线程是不会释放的，即使它是Idle。这就会产生性能问题，比如如果线程池的大小为200，当全部使用完毕后，所有的线程会继续留在池中，相应的内存和线程切换（while(true)+sleep循环）都会增加。如果要避免这个问题，就必须直接使用ThreadPoolExecutor()来构造。可以像Tomcat的线程池一样设置“最大线程数”、“最小线程数”和“空闲线程keepAlive的时间”。通过这些可以基本上替换Tomcat的线程池实现方案。

需要注意的是线程池必须使用shutdown来显式关闭，否则主线程就无法退出。shutdown也不会阻塞主线程。

许 多长时间运行的应用有时候需要定时运行任务完成一些诸如统计、优化等工作，比如在电信行业中处理用户话单时，需要每隔1分钟处理话单；网站每天凌晨统计用户访问量、用户数；大型超时凌晨3点统计当天销售额、以及最热卖的商品；每周日进行数据库备份；公司每个月的10号计算工资并进行转帐等，这些都是定时任务。通过 java的并发库concurrent 可以轻松的完成这些任务，而且非常的简单。

Java代码 复制代码
  1. package concurrent;   
  2. import static java.util.concurrent.TimeUnit.SECONDS;   
  3. import java.util.Date;   
  4. import java.util.concurrent.Executors;   
  5. import java.util.concurrent.ScheduledExecutorService;   
  6. import java.util.concurrent.ScheduledFuture;   
  7. public class TestScheduledThread {   
  8.   public static void main(String[] args) {   
  9.     final ScheduledExecutorService scheduler = Executors   
  10.         .newScheduledThreadPool(2);   
  11.     final Runnable beeper = new Runnable() {   
  12.       int count = 0;   
  13.       public void run() {   
  14.         System.out.println(new Date() + " beep " + (++count));   
  15.       }   
  16.     };   
  17.     // 1秒钟后运行，并每隔2秒运行一次   
  18.     final ScheduledFuture<?> beeperHandle = scheduler.scheduleAtFixedRate(   
  19.         beeper, 1, 2, SECONDS);   
  20.     // 2秒钟后运行，并每次在上次任务运行完后等待5秒后重新运行   
  21.     final ScheduledFuture<?> beeperHandle2 = scheduler   
  22.         .scheduleWithFixedDelay(beeper, 2, 5, SECONDS);   
  23.     // 30秒后结束关闭任务，并且关闭Scheduler   
  24.     scheduler.schedule(new Runnable() {   
  25.       public void run() {   
  26.         beeperHandle.cancel(true);   
  27.         beeperHandle2.cancel(true);   
  28.         scheduler.shutdown();   
  29.       }   
  30.     }, 30, SECONDS);   
  31.   }   
  32. }  
 

为了退出进程，上面的代码中加入了关闭Scheduler的操作。而对于24小时运行的应用而言，是没有必要关闭Scheduler的。

    在 实际应用中，有时候需要多个线程同时工作以完成同一件事情，而且在完成过程中，往往会等待其他线程都完成某一阶段后再执行，等所有线程都到达某一个阶段后再统一执行。

    比如有几个旅行团需要途经深圳、广州、韶关、长沙最后到达武汉。旅行团中有自驾游的，有徒步的，有乘坐旅游大巴的；这些旅行团同时出发，并且每到一个目的地，都要等待其他旅行团到达此地后再同时出发，直到都到达终点站武汉。

这时候CyclicBarrier 就可以派上用场。CyclicBarrier最重要的属性就是参与者个数，另外最要方法是await()。当所有线程都调用了await()后，就表示这些线程都可以继续执行，否则就会等待。

Java代码 复制代码
  1. package concurrent;   
  2. import java.text.SimpleDateFormat;   
  3. import java.util.Date;   
  4. import java.util.concurrent.BrokenBarrierException;   
  5. import java.util.concurrent.CyclicBarrier;   
  6. import java.util.concurrent.ExecutorService;   
  7. import java.util.concurrent.Executors;   
  8. public class TestCyclicBarrier {   
  9.   // 徒步需要的时间: Shenzhen, Guangzhou, Shaoguan, Changsha, Wuhan   
  10.   private static int[] timeWalk = { 5, 8, 15, 15, 10 };   
  11.   // 自驾游   
  12.   private static int[] timeSelf = { 1, 3, 4, 4, 5 };   
  13.   // 旅游大巴   
  14.   private static int[] timeBus = { 2, 4, 6, 6, 7 };   
  15.      
  16.   static String now() {   
  17.     SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");   
  18.     return sdf.format(new Date()) + ": ";   
  19.   }   
  20.   
  21.   static class Tour implements Runnable {   
  22.     private int[] times;   
  23.     private CyclicBarrier barrier;   
  24.     private String tourName;   
  25.     public Tour(CyclicBarrier barrier, String tourName, int[] times) {   
  26.       this.times = times;   
  27.       this.tourName = tourName;   
  28.       this.barrier = barrier;   
  29.     }   
  30.     public void run() {   
  31.       try {   
  32.         Thread.sleep(times[0] * 1000);   
  33.         System.out.println(now() + tourName + " Reached Shenzhen");   
  34.         barrier.await();   
  35.         Thread.sleep(times[1] * 1000);   
  36.         System.out.println(now() + tourName + " Reached Guangzhou");   
  37.         barrier.await();   
  38.         Thread.sleep(times[2] * 1000);   
  39.         System.out.println(now() + tourName + " Reached Shaoguan");   
  40.         barrier.await();   
  41.         Thread.sleep(times[3] * 1000);   
  42.         System.out.println(now() + tourName + " Reached Changsha");   
  43.         barrier.await();   
  44.         Thread.sleep(times[4] * 1000);   
  45.         System.out.println(now() + tourName + " Reached Wuhan");   
  46.         barrier.await();   
  47.       } catch (InterruptedException e) {   
  48.       } catch (BrokenBarrierException e) {   
  49.       }   
  50.     }   
  51.   }   
  52.   
  53.   public static void main(String[] args) {   
  54.     // 三个旅行团   
  55.     CyclicBarrier barrier = new CyclicBarrier(3);   
  56.     ExecutorService exec = Executors.newFixedThreadPool(3);   
  57.     exec.submit(new Tour(barrier, "WalkTour", timeWalk));   
  58.     exec.submit(new Tour(barrier, "SelfTour", timeSelf));   
  59.     exec.submit(new Tour(barrier, "BusTour", timeBus));   
  60.     exec.shutdown();   
  61.   }   
  62. }  
 

运行结果：
00:02:25: SelfTour Reached Shenzhen
00:02:25: BusTour Reached Shenzhen
00:02:27: WalkTour Reached Shenzhen
00:02:30: SelfTour Reached Guangzhou
00:02:31: BusTour Reached Guangzhou
00:02:35: WalkTour Reached Guangzhou
00:02:39: SelfTour Reached Shaoguan
00:02:41: BusTour Reached Shaoguan

    并 发库中的BlockingQueue 是一个比较好玩的类，顾名思义，就是阻塞队列。该类主要提供了两个方法put()和take()，前者将一个对象放到队列中，如果队列已经满了，就等待直到有空闲节点；后者从head取一个对象，如果没有对象，就等待直到有可取的对象。

下面的例子比较简单，一个读线程，用于将要处理的文件对象添加到阻塞队列中，另外四个写线程用于取出文件对象，为了模拟写操作耗时长的特点，特让线程睡眠一段随机长度的时间。另外，该Demo也使用到了线程池和原子整型（AtomicInteger），AtomicInteger可以在并发情况下达到原子化更新，避免使用了synchronized，而且性能非常高。由于阻塞队列的put和take操作会阻塞，为了使线程退出，特在队列中添加了一个“标识”，算法中也叫“哨兵”，当发现这个哨兵后，写线程就退出。

当然线程池也要显式退出了。

Java代码 复制代码
  1. package concurrent;   
  2. import java.io.File;   
  3. import java.io.FileFilter;   
  4. import java.util.concurrent.BlockingQueue;   
  5. import java.util.concurrent.ExecutorService;   
  6. import java.util.concurrent.Executors;   
  7. import java.util.concurrent.LinkedBlockingQueue;   
  8. import java.util.concurrent.atomic.AtomicInteger;   
  9.   
  10. public class TestBlockingQueue {   
  11.   static long randomTime() {   
  12.     return (long) (Math.random() * 1000);   
  13.   }   
  14.   
  15.   public static void main(String[] args) {   
  16.     // 能容纳100个文件   
  17.     final BlockingQueue<File> queue = new LinkedBlockingQueue<File>(100);   
  18.     // 线程池   
  19.     final ExecutorService exec = Executors.newFixedThreadPool(5);   
  20.     final File root = new File("F://JavaLib");   
  21.     // 完成标志   
  22.     final File exitFile = new File("");   
  23.     // 读个数   
  24.     final AtomicInteger rc = new AtomicInteger();   
  25.     // 写个数   
  26.     final AtomicInteger wc = new AtomicInteger();   
  27.     // 读线程   
  28.     Runnable read = new Runnable() {   
  29.       public void run() {   
  30.         scanFile(root);   
  31.         scanFile(exitFile);   
  32.       }   
  33.   
  34.       public void scanFile(File file) {   
  35.         if (file.isDirectory()) {   
  36.           File[] files = file.listFiles(new FileFilter() {   
  37.             public boolean accept(File pathname) {   
  38.               return pathname.isDirectory()   
  39.                   || pathname.getPath().endsWith(".java");   
  40.             }   
  41.           });   
  42.           for (File one : files)   
  43.             scanFile(one);   
  44.         } else {   
  45.           try {   
  46.             int index = rc.incrementAndGet();   
  47.             System.out.println("Read0: " + index + " "  
  48.                 + file.getPath());   
  49.             queue.put(file);   
  50.           } catch (InterruptedException e) {   
  51.           }   
  52.         }   
  53.       }   
  54.     };   
  55.     exec.submit(read);   
  56.     // 四个写线程   
  57.     for (int index = 0; index < 4; index++) {   
  58.       // write thread   
  59.       final int NO = index;   
  60.       Runnable write = new Runnable() {   
  61.         String threadName = "Write" + NO;   
  62.         public void run() {   
  63.           while (true) {   
  64.             try {   
  65.               Thread.sleep(randomTime());   
  66.               int index = wc.incrementAndGet();   
  67.               File file = queue.take();   
  68.               // 队列已经无对象   
  69.               if (file == exitFile) {   
  70.                 // 再次添加"标志"，以让其他线程正常退出   
  71.                 queue.put(exitFile);   
  72.                 break;   
  73.               }   
  74.               System.out.println(threadName + ": " + index + " "  
  75.                   + file.getPath());   
  76.             } catch (InterruptedException e) {   
  77.             }   
  78.           }   
  79.         }   
  80.       };   
  81.       exec.submit(write);   
  82.     }   
  83.     exec.shutdown();   
  84.   }   
  85. }  
 

从 名字可以看出，CountDownLatch 是一个倒数计数的锁，当倒数到0时触发事件，也就是开锁，其他人就可以进入了。在一些应用场合中，需要等待某个条件达到要求后才能做后面的事情；同时当线程都完成后也会触发事件，以便进行后面的操作。

CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。

一个CountDouwnLatch实例是不能重复使用的，也就是说它是一次性的，锁一经被打开就不能再关闭使用了，如果想重复使用，请考虑使用CyclicBarrier 。

下面的例子简单的说明了CountDownLatch的使用方法，模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。

同样，线程池需要显式shutdown。

Java代码 复制代码
  1. package concurrent;   
  2.   
  3. import java.util.concurrent.CountDownLatch;   
  4. import java.util.concurrent.ExecutorService;   
  5. import java.util.concurrent.Executors;   
  6.   
  7. public class TestCountDownLatch {   
  8.   public static void main(String[] args) throws InterruptedException {   
  9.     // 开始的倒数锁   
  10.     final CountDownLatch begin = new CountDownLatch(1);   
  11.     // 结束的倒数锁   
  12.     final CountDownLatch end = new CountDownLatch(10);   
  13.     // 十名选手   
  14.     final ExecutorService exec = Executors.newFixedThreadPool(10);   
  15.     for(int index = 0; index < 10; index++) {   
  16.       final int NO = index + 1;   
  17.       Runnable run = new Runnable(){   
  18.         public void run() {   
  19.           try {   
  20.             begin.await();   
  21.             Thread.sleep((long) (Math.random() * 10000));   
  22.             System.out.println("No." + NO + " arrived");   
  23.           } catch (InterruptedException e) {   
  24.           } finally {   
  25.             end.countDown();   
  26.           }   
  27.         }   
  28.       };   
  29.       exec.submit(run);   
  30.     }   
  31.     System.out.println("Game Start");   
  32.     begin.countDown();   
  33.     end.await();   
  34.     System.out.println("Game Over");   
  35.     exec.shutdown();   
  36.   }   
  37. }  
 

运行结果:
Game Start
No.4 arrived
No.1 arrived
No.7 arrived
No.9 arrived
No.3 arrived
No.2 arrived
No.8 arrived
No.10 arrived
No.6 arrived
No.5 arrived
Game Over

有 时候在实际应用中，某些操作很耗时，但又不是不可或缺的步骤。比如用网页浏览器浏览新闻时，最重要的是要显示文字内容，至于与新闻相匹配的图片就没有那么重要的，所以此时首先保证文字信息先显示，而图片信息会后显示，但又不能不显示，由于下载图片是一个耗时的操作，所以必须一开始就得下载。

Java的并发库 的Future 类就可以满足这个要求。Future的重要方法包括get()和cancel()，get()获取数据对象，如果数据没有加载，就会阻塞直到取到数据，而 cancel()是取消数据加载。另外一个get(timeout)操作，表示如果在timeout时间内没有取到就失败返回，而不再阻塞。

下面的Demo简单的说明了Future的使用方法：一个非常耗时的操作必须一开始启动，但又不能一直等待；其他重要的事情又必须做，等完成后，就可以做不重要的事情。

Java代码 复制代码
  1. package concurrent;   
  2.   
  3. import java.util.concurrent.Callable;   
  4. import java.util.concurrent.ExecutionException;   
  5. import java.util.concurrent.ExecutorService;   
  6. import java.util.concurrent.Executors;   
  7. import java.util.concurrent.Future;   
  8.   
  9. public class TestFutureTask {   
  10.   public static void main(String[] args)throws InterruptedException,   
  11.       ExecutionException {   
  12.     final ExecutorService exec = Executors.newFixedThreadPool(5);   
  13.     Callable<String> call = new Callable<String>() {   
  14.       public String call() throws Exception {   
  15.         Thread.sleep(1000 * 5);   
  16.         return "Other less important but longtime things.";   
  17.       }   
  18.     };   
  19.     Future<String> task = exec.submit(call);   
  20.     // 重要的事情   
  21.     Thread.sleep(1000 * 3);   
  22.     System.out.println("Let's do important things.");   
  23.     // 其他不重要的事情   
  24.     String obj = task.get();   
  25.     System.out.println(obj);   
  26.     // 关闭线程池   
  27.     exec.shutdown();   
  28.   }   
  29. }  
 

运行结果：
Let's do important things.
Other less important but longtime things.

 

考 虑以下场景：浏览网页时，浏览器了5个线程下载网页中的图片文件，由于图片大小、网站访问速度等诸多因素的影响，完成图片下载的时间就会有很大的不同。如果先下载完成的图片就会被先显示到界面上，反之，后下载的图片就后显示。

Java的并发库 的CompletionService 可以满足这种场景要求。该接口有两个重要方法：submit()和take()。submit用于提交一个runnable或者callable，一般会提交给一个线程池处理；而take就是取出已经执行完毕runnable或者callable实例的Future对象，如果没有满足要求的，就等待了。 CompletionService还有一个对应的方法poll，该方法与take类似，只是不会等待，如果没有满足要求，就返回null对象。

Java代码 复制代码
  1. package concurrent;   
  2.   
  3. import java.util.concurrent.Callable;   
  4. import java.util.concurrent.CompletionService;   
  5. import java.util.concurrent.ExecutionException;   
  6. import java.util.concurrent.ExecutorCompletionService;   
  7. import java.util.concurrent.ExecutorService;   
  8. import java.util.concurrent.Executors;   
  9. import java.util.concurrent.Future;   
  10.   
  11. public class TestCompletionService {   
  12.   public static void main(String[] args) throws InterruptedException,   
  13.       ExecutionException {   
  14.     ExecutorService exec = Executors.newFixedThreadPool(10);   
  15.     CompletionService<String> serv =    
  16.       new ExecutorCompletionService<String>(exec);   
  17.   
  18.     for (int index = 0; index < 5; index++) {   
  19.       final int NO = index;   
  20.       Callable<String> downImg = new Callable<String>() {   
  21.         public String call() throws Exception {   
  22.           Thread.sleep((long) (Math.random() * 10000));   
  23.           return "Downloaded Image " + NO;   
  24.         }   
  25.       };   
  26.       serv.submit(downImg);   
  27.     }   
  28.   
  29.     Thread.sleep(1000 * 2);   
  30.     System.out.println("Show web content");   
  31.     for (int index = 0; index < 5; index++) {   
  32.       Future<String> task = serv.take();   
  33.       String img = task.get();   
  34.       System.out.println(img);   
  35.     }   
  36.     System.out.println("End");   
  37.     // 关闭线程池   
  38.     exec.shutdown();   
  39.   }   
  40. }  
 

运行结果:
Show web content
Downloaded Image 1
Downloaded Image 2
Downloaded Image 4
Downloaded Image 0
Downloaded Image 3
End

 

操作系统的信号量是个很重要的概念，在进程控制方面都有应用。 Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，acquire()获取一个许可，如果没有就等待，而release()释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。

Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁ReentrantLock也可以实现该功能，但实现上要负责些，代码也要复杂些。

下面的Demo中申明了一个只有5个许可的Semaphore，而有20个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。

Java代码 复制代码
  1. package concurrent;   
  2.   
  3. import java.util.concurrent.ExecutorService;   
  4. import java.util.concurrent.Executors;   
  5. import java.util.concurrent.Semaphore;   
  6.   
  7. public class TestSemaphore {   
  8.   public static void main(String[] args) {   
  9.     // 线程池   
  10.     ExecutorService exec = Executors.newCachedThreadPool();   
  11.     // 只能5个线程同时访问   
  12.     final Semaphore semp = new Semaphore(5);   
  13.     // 模拟20个客户端访问   
  14.     for (int index = 0; index < 20; index++) {   
  15.       final int NO = index;   
  16.       Runnable run = new Runnable() {   
  17.         public void run() {   
  18.           try {   
  19.             // 获取许可   
  20.             semp.acquire();   
  21.             System.out.println("Accessing: " + NO);   
  22.             Thread.sleep((long) (Math.random() * 10000));   
  23.             // 访问完后，释放   
  24.             semp.release();   
  25.           } catch (InterruptedException e) {   
  26.           }   
  27.         }   
  28.       };   
  29.       exec.execute(run);   
  30.     }   
  31.     // 退出线程池   
  32.     exec.shutdown();   
  33.   }   
  34. }  

 运行结果：
Accessing: 0
Accessing: 1
Accessing: 2
Accessing: 3
Accessing: 4
Accessing: 5
Accessing: 6
Accessing: 7
Accessing: 8
Accessing: 9
Accessing: 10
Accessing: 11
Accessing: 12
Accessing: 13
Accessing: 14
Accessing: 15
Accessing: 16
Accessing: 17
Accessing: 18
Accessing: 19

跑步机推荐 知乎 跑步机推荐 知乎
原创粉丝点击
热门IT博客
win10 usb共享网络win10 usb共享网络
c 定义常量数组c 定义常量数组
葡萄妈家的鞋子知乎
国外即时通讯软件排名
问卷平台知乎
windows 8三维弹珠在哪
淘宝断码折扣店
支持pe编程的单片机
詹姆斯mvp赛季数据
约束满足问题 推荐算法
怎样下载录音软件
黑鹰直升机 中国 知乎
剑三脸型数据库
263电话会议软件下载
网络直复营销理论类型
2017淘宝互刷微信群
网络协议三要素的关系
最有效的网络推广方法
app自制软件
windows nas方案
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 换电脑了系统怎么办 电脑看直播黑屏怎么办 网页打开不是全屏怎么办 电脑开不起来怎么办 tcl电视没有太怎么办 电脑死机了怎么办黑屏 qq删掉了信息怎么办 苹果手机屏幕字体变大怎么办 穿越火线老是230怎么办 iped密码忘了怎么办 ipad屏幕倒了怎么办 苹果充电器掉了怎么办 ipad软件更新不了怎么办 pr没有弹出字幕怎么办 税务稽查交不上税款怎么办 孩子爱玩电脑游戏怎么办 孩子总爱说谎怎么办 网易云登录超时怎么办? 网易云认证失败怎么办 产后吃饭胃疼怎么办 太饿吃饭胃痛怎么办 不吃饭胃疼怎么办 胃疼疼了两天了怎么办 胃痛了一晚上怎么办 肚子胀胃不舒服怎么办 胃痛一天了还没好怎么办 胃疼一天了怎么办 胃疼两天了怎么办 胃疼不想吃饭怎么办 无意间吃了胃药怎么办 让果树不结果怎么办 qq邮箱忘了怎么办 证券号码忘记了怎么办 vivovv帐号过期了怎么办 注册不了微信号怎么办 单招考试不通过怎么办? icloud连接不上怎么办 爱奇艺老是闪退怎么办 爱奇艺总是闪退怎么办 qq最小化后不见了怎么办 网页最小化后不见了怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里