Java ExecutorService.execute方法代码示例

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
public void testOfferInExecutor(boolean fair) {
    final SynchronousQueue q = new SynchronousQueue(fair);
    final CheckedBarrier threadsStarted = new CheckedBarrier(2);
    final ExecutorService executor = Executors.newFixedThreadPool(2);
    try (PoolCleaner cleaner = cleaner(executor)) {

        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertFalse(q.offer(one));
                threadsStarted.await();
                assertTrue(q.offer(one, LONG_DELAY_MS, MILLISECONDS));
                assertEquals(0, q.remainingCapacity());
            }});

        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                threadsStarted.await();
                assertSame(one, q.take());
            }});
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * timed poll retrieves elements across Executor threads
 */
public void testPollInExecutor() {
    final LinkedTransferQueue q = new LinkedTransferQueue();
    final CheckedBarrier threadsStarted = new CheckedBarrier(2);
    final ExecutorService executor = Executors.newFixedThreadPool(2);
    try (PoolCleaner cleaner = cleaner(executor)) {

        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertNull(q.poll());
                threadsStarted.await();
                long startTime = System.nanoTime();
                assertSame(one, q.poll(LONG_DELAY_MS, MILLISECONDS));
                assertTrue(millisElapsedSince(startTime) < LONG_DELAY_MS);
                checkEmpty(q);
            }});

        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                threadsStarted.await();
                q.put(one);
            }});
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
public static void main(String[] args) {
    //创建并发访问的账户
    MyCount myCount = new MyCount("95599200901215522", 10000);
    //创建一个锁对象
    ReadWriteLock lock = new ReentrantReadWriteLock(false);
    //创建一个线程池
    ExecutorService pool = Executors.newFixedThreadPool(2);
    //创建一些并发访问用户，一个信用卡，存的存，取的取，好热闹啊
    User u1 = new User("张三", myCount, -4000, lock, true);
    User u2 = new User("张三他爹", myCount, 6000, lock, false);
    User u3 = new User("张三他弟", myCount, -8000, lock, false);
    User u4 = new User("张三", myCount, 800, lock, false);
    User u5 = new User("张三他爹", myCount, 0, lock, true);
    //在线程池中执行各个用户的操作
    pool.execute(u1);
    pool.execute(u2);
    pool.execute(u3);
    pool.execute(u4);
    pool.execute(u5);
    //关闭线程池
    pool.shutdown();
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
public void startClient()
{
   try // connect to server and get streams
   {
      // make connection to server
      connection = new Socket(
         InetAddress.getByName(ticTacToeHost), 12345);

      // get streams for input and output
      input = new Scanner(connection.getInputStream());
      output = new Formatter(connection.getOutputStream());
   } 
   catch (IOException ioException)
   {
      ioException.printStackTrace();         
   } 

   // create and start worker thread for this client
   ExecutorService worker = Executors.newFixedThreadPool(1);
   worker.execute(this); // execute client
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
private void generateMaxSet() throws AlgorithmExecutionException {

        if (this.optimize()) {
            this.maxSet = new CopyOnWriteArrayList<MAX_SET>();
            ExecutorService exec = this.getExecuter();
            for (int i = 0; i < this.numberOfAttributes; ++i) {
                exec.execute(new RunnerThreadMaxSet(i));
            }
            this.awaitExecuter(exec);
        } else {
            this.maxSet = new LinkedList<MAX_SET>();
            for (int i = 0; i < this.numberOfAttributes; ++i) {
                executeMax_Set_Task(i);
            }
        }

    }
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * timed poll transfers elements across Executor tasks
 */
public void testPollInExecutor() {
    final DelayQueue q = new DelayQueue();
    final CheckedBarrier threadsStarted = new CheckedBarrier(2);
    final ExecutorService executor = Executors.newFixedThreadPool(2);
    try (PoolCleaner cleaner = cleaner(executor)) {
        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                assertNull(q.poll());
                threadsStarted.await();
                assertNotNull(q.poll(LONG_DELAY_MS, MILLISECONDS));
                checkEmpty(q);
            }});

        executor.execute(new CheckedRunnable() {
            public void realRun() throws InterruptedException {
                threadsStarted.await();
                q.put(new PDelay(1));
            }});
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
public static void main(String[] args) throws Throwable {
    final int nThreads = 16;
    final int writes = 1000;
    final File file = File.createTempFile("foo", null);
    try {
        ExecutorService pool = Executors.newFixedThreadPool(nThreads);
        for (int i = 0; i < nThreads; i++)
            pool.execute(new Runnable() { public void run() {
                try {
                    // randomly choose FileChannel or OutputStream
                    if (rand.nextBoolean()) {
                        try (FileChannel fc = newFileChannel(file)) {
                            for (int j=0; j<writes; j++) write(fc, 'x');
                        }
                    } else {
                        try (OutputStream out = newOutputStream(file)) {
                            for (int j = 0; j<writes; j++) out.write('x');
                        }
                    }
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }});
        pool.shutdown();
        pool.awaitTermination(1L, TimeUnit.MINUTES);
        if (file.length() != (long) (nThreads * writes))
            throw new RuntimeException("File not expected length");
    } finally {
        file.delete();
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/** 根据Id查询(cls返回类型Class) */
public <K> Page<K> getPage(final Page<Long> ids, final Class<K> cls) {
	if (ids != null) {
		Page<K> page = new Page<K>(ids.getCurrent(), ids.getSize());
		page.setTotal(ids.getTotal());
		final List<K> records = InstanceUtil.newArrayList();
		for (int i = 0; i < ids.getRecords().size(); i++) {
			records.add(null);
		}
		int thread = Math.min(maxThread, Math.max(1, records.size() / 2));
		ExecutorService executorService = Executors.newFixedThreadPool(thread);
		for (int i = 0; i < ids.getRecords().size(); i++) {
			final int index = i;
			executorService.execute(new Runnable() {
				public void run() {
					T t = queryById(ids.getRecords().get(index));
					K k = InstanceUtil.to(t, cls);
					records.set(index, k);
				}
			});
		}
		executorService.shutdown();
		try {
			executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS);
		} catch (InterruptedException e) {
			logger.error("awaitTermination", "", e);
		}
		page.setRecords(records);
		return page;
	}
	return new Page<K>();
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
public void scanportsetfun() {
   	 int threadNum;
        threadNum=Integer.parseInt(TheardNum.getText().trim());
        String[] portsString = textportlist.getText().split(",");
        
        int[] ports = new int[portsString.length];
        
        for(int ii=0;ii<portsString.length;ii++)
            ports[ii] = Integer.parseInt(portsString[ii].trim());
        
        Result.append("scanning"+" "+Lsaportscan.hostaddress+"'s port set!"+"\n");
        ExecutorService threadPool = Executors.newCachedThreadPool();
        for (int i = 0; i < threadNum; i++) {
        	 Portset portset = new Portset(ports,threadNum,i);
         	 threadPool.execute(portset);
        }
        
        threadPool.shutdown();
        
        while (true) {
         	
            if (threadPool.isTerminated()) {
                //System.out.println("OVER!!!!!!!!!!!!!!!");
                Result.append("-------------------------Over!!!----------------------\n\n");
                stateResult.setText("OVER !");  
                break;
            }
        
            try {
               		Thread.sleep(1000);
            } catch (InterruptedException e1) {
        }  
    }
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    String passPath = "password.txt";
    String dictPath = "dictionary.txt";

    System.out.println("Loading dictionary");

    List<String> dictionary = new ArrayList<String>();

    // store dictionary file in memory
    try (BufferedReader reader = new BufferedReader(new FileReader(dictPath))) {
        String line;
        while ((line = reader.readLine()) != null) {
            dictionary.add(line);
        }
    } catch (IOException e) {
        e.printStackTrace();
    }

    System.out.println("Dictionary loaded");

    ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());

    // queue of items (containing a word and it's hash equivalent) added to by producers, taken by consumer
    BlockingQueue<Item> queue = new LinkedBlockingQueue<Item>();

    // checks given hashed word from producers against hashes stored in password text file
    // single consumer serialises writes, avoids concurrent mangling of output file
    Runnable consumer = new Consumer(queue, passPath);
    executor.execute(consumer);
    System.out.println("Consumer started");

    // each thread has increasing approximate computation time based on i
    for (int i = 1; i <= 20; i++) {
        // hashes words from those stored in dictionary text file, sends to consumer to check
        Runnable producer = new Producer(queue, dictionary, i);
        executor.execute(producer);
        System.out.println("Producer " + i + " started");
    }

}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
public void testDubboMultiThreadInvoke() throws Exception
{
    Exporter<?> rpcExporter = protocol.export(proxy.getInvoker(new DemoServiceImpl(), DemoService.class, URL.valueOf("dubbo://127.0.0.1:20259/TestService")));
	
	final AtomicInteger counter = new AtomicInteger();
	final DemoService service = proxy.getProxy(protocol.refer(DemoService.class, URL.valueOf("dubbo://127.0.0.1:20259/TestService")));
	assertEquals(service.getSize(new String[]{"123", "456", "789"}), 3);

	final StringBuffer sb = new StringBuffer();
	for(int i=0;i<1024*64+32;i++)
		sb.append('A');
	assertEquals(sb.toString(), service.echo(sb.toString()));

	ExecutorService exec = Executors.newFixedThreadPool(10);
	for(int i=0;i<10;i++)
	{
		final int fi = i;
		exec.execute(new Runnable(){
			public void run()
			{
				for(int i=0;i<30;i++)
				{
					System.out.println(fi+":"+counter.getAndIncrement());
					assertEquals(service.echo(sb.toString()), sb.toString());
				}
			}
		});
	}
	exec.shutdown();
	exec.awaitTermination(10, TimeUnit.SECONDS);
	rpcExporter.unexport();
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
protected void testMultiInstanceConcurrencySequentiallyLaunched(int iterations, final RedissonRunnable runnable) throws InterruptedException {
    System.out.println("Multi Instance Concurrent Job Interation: " + iterations);
    ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() * 2);

    final Map<Integer, RedissonClient> instances = new HashMap<Integer, RedissonClient>();
    for (int i = 0; i < iterations; i++) {
        instances.put(i, BaseTest.createInstance());
    }

    long watch = System.currentTimeMillis();
    for (int i = 0; i < iterations; i++) {
        final int n = i;
        executor.execute(() -> runnable.run(instances.get(n)));
    }

    executor.shutdown();
    Assert.assertTrue(executor.awaitTermination(5, TimeUnit.MINUTES));

    System.out.println("multi: " + (System.currentTimeMillis() - watch));

    executor = Executors.newCachedThreadPool();

    for (final RedissonClient redisson : instances.values()) {
        executor.execute(() -> redisson.shutdown());
    }

    executor.shutdown();
    Assert.assertTrue(executor.awaitTermination(5, TimeUnit.MINUTES));
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * 启动多线程查询
 */
public void go() {
    ExecutorService executorService = Executors.newFixedThreadPool(Integer.parseInt(Constant.THREAD_POOL_SIZE));
    for (int i = 0; i < Integer.parseInt(Constant.THREAD_NUM); ++i) {
        log.info("thread " + i + " is ready start!");

        executorService.execute(new Task());

        log.info("thread " + i + " has finished!");
    }
    executorService.shutdown();
}
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
     * @param args
     */
    public static void main(String[] args) {
        final List<Integer> list = new ArrayList<Integer>(52);
        
        ExecutorService service = Executors.newFixedThreadPool(50);
        
        int i = 0;
        while (i++ < 50) {
            service.execute(new Runnable() {
                
                @Override
                public void run() {
//                    while (true) {
//                        try {
//                            Thread.sleep(10);
//                        } catch (InterruptedException e) {
//                            // TODO Auto-generated catch block
//                            e.printStackTrace();
//                        }
                        Random r = new Random();
                        list.add(r.nextInt(30));
//                    }
                }
            });
        }
        
        while(true) {
            System.out.println(list.size());
        }
    }
 

import java.util.concurrent.ExecutorService; //导入方法依赖的package包/类
/**
 * Runs the command.
 *
 * @param command the list of command line tokens
 * @return the output of the command as a list of lines
 * @throws GradleException if the command exited with non-zero exit code
 */
public List<String> run(List<String> command) throws IOException, InterruptedException {
  if (logger != null) {
    logger.debug("Running command : " + String.join(" ", command));
  }

  ExecutorService executor = executorServiceFactory.createExecutorService();

  // Builds the command to execute.
  ProcessBuilder processBuilder = processBuilderFactory.createProcessBuilder();
  processBuilder.command(command);
  processBuilder.redirectErrorStream(true);
  if (environment != null) {
    processBuilder.environment().putAll(environment);
  }
  final Process process = processBuilder.start();

  // Runs the command and streams the output.
  List<String> output = new ArrayList<>();
  executor.execute(outputConsumerRunnable(process, output));
  int exitCode = process.waitFor();

  // Shuts down the executor.
  executor.shutdown();

  try {
    executor.awaitTermination(TIMEOUT_SECONDS, TimeUnit.SECONDS);
  } catch (InterruptedException ex) {
    if (logger != null) {
      logger.debug("Task Executor interrupted waiting for output consumer thread");
    }
  }

  // Stops the build if the command fails to do something, we may want to make this configurable.
  if (exitCode != 0) {
    throw new GradleException("command exited with non-zero exit code : " + exitCode);
  }

  return output;
}