线程池的简单Demo

服务器端:

public class Server {
    private int port=8821;
    private ServerSocket serverSocket;
    private ExecutorService executorService;//线程池
    private final int POOL_SIZE=10;//单个CPU线程池大小

    public MultiThreadServer()throws IOException{
        serverSocket=new ServerSocket(port);
        //Runtime的availableProcessor()方法返回当前系统的CPU数目.
        executorService=Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors()*POOL_SIZE);
        System.out.println("服务器启动!");
    }  

    public void service(){
        while(true){
            Socket socket=null;
            try {
                //接收客户连接,只要客户进行了连接,就会触发accept();建立连接!
                socket=serverSocket.accept();
                executorService.execute(new ServerConThread(socket));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }  

    public static void main(String[] args)throws IOException {
        new Server().service();
    }  

}  

线程:


public class ServerConThread implements Runnable{  

    private PrintWriter pw =null;
    private BufferedReader br=null;
    private Socket socket;
    public ServerConThread(Socket socket){
        this.socket=socket;
    }
    private PrintWriter getWriter(Socket socket)throws IOException{
        OutputStream socketOut=socket.getOutputStream();
        return new PrintWriter(socketOut,true);
    }
    private BufferedReader getReader(Socket socket)throws IOException{
        InputStream socketIn=socket.getInputStream();
        return new BufferedReader(new InputStreamReader(socketIn));
    }    

    public void run(){
        try {
            System.out.println("新的连接: "+socket.getInetAddress()+":"+socket.getPort());
            br=getReader(socket);
            pw=getWriter(socket);
            String msg=null;
            while((msg=br.readLine())!=null){
                System.out.println("客户端说:"msg);
                pw.println("我是服务器!");

            }
            br.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("输入输出流异常!");
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
            try {
                if(socket!=null)
                    socket.close();
            } catch (IOException e) {
                e.printStackTrace();
                System.out.println("输入输出流异常!);
            }
        }
    }
}

客户端:

public class Client {

    public static void main(String[] args) {
        int numTasks = 10;  

        ExecutorService exec = Executors.newCachedThreadPool();
        for(int i=0;i<10;i++){
            exec.execute(createTask(i));
        }
    }  

    // 定义了一个简单的任务
    private static Runnable createTask(final int taskID) {
        return new Runnable() {
            private Socket socket =null;
            private int port=6666;

            public void run() {
                System.out.println("任务 " + taskID +":开始");
                try {
                    socket = new Socket("localhost", port);
                    OutputStream socketOut = socket.getOutputStream();

                    PrintWriter pw = new PrintWriter(socketOut);
                    pw.println("我是客户端!");

                    pw.flush();
                    // 接收服务器的反馈
                    BufferedReader br = new BufferedReader(
                            new InputStreamReader(socket.getInputStream()));
                    String msg = null;
                    while ((msg = br.readLine()) !=null)
                        System.out.println(msg);
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }  

        };
    }
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-09-30 07:08:20

线程池的简单Demo的相关文章

线程池的简单实现

几个基本的线程函数: //线程操纵函数//创建:   int pthread_create(pthread_t *tidp, const pthread_attr_t *attr, (void*)(*start_rtn)(void *), void *arg);//终止自身    void pthread_exit(void *retval);//终止其他:   int pthread_cancel(pthread_t tid); 发送终止信号后目标线程不一定终止,要调用join函数等待//阻塞

一个线程池的简单的实现

线程池实现: 用于执行大量相对短暂的任务 当任务增加的时候能够动态的增加线程池中线程的数量直到达到一个阈值. 当任务执行完毕的时候,能够动态的销毁线程池中的线程 该线程池的实现本质上也是生产者与消费模型的应用.生产者线程向任务队列中添加任务,一旦队列有任务到来,如果有等待线程就唤醒来执行任务,如果没有等待线程并且线程数没有达到阈值,就创建新线程来执行任务. contion.h #ifndef _CONDITION_H_ #define _CONDITION_H_ #include <pthrea

JAVA中线程池的简单使用

比如现在有10个线程,但每次只想运行3个线程,当这3个线程中的任何一个运行完后,第4个线程接着补上.这种情况可以使用线程池来解决,线程池用起来也相当的简单,不信,你看: package com.demo; import java.util.ArrayList; import java.util.Collection; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public

JAVA线程池应用的DEMO

在做很多高并发应用的时候,单线程的瓶颈已经满足不了我们的需求,此时使用多线程来提高处理速度已经是比较常规的方案了.在使用多线程的时候,我们可以使用线程池来管理我们的线程,至于使用线程池的优点就不多说了. Java线程池说起来也简单,简单说下继承关系: ThreadPoolExecutor extends AbstractExecutorService implements ExecutorService extends Executor 还有一个支持延时执行线程和可以重复执行线程的实现类: Sc

Linux组件封装(七)——线程池的简单封装

线程池的封装,基础思想与生产者消费者的封装一样,只不过我们是将线程池封装为自动获取任务.执行任务,让用户调用相应的接口来添加任务. 在线程池的封装中,我们同样需要用到的是MutexLock.Condition.Thread这些基本的封装. 基础封装如下: MutexLock: 1 #ifndef MUTEXLOCK_H 2 #define MUTEXLOCK_H 3 4 #include "NonCopyable.h" 5 #include <pthread.h> 6 #i

Java ExecutorService四种线程池的简单使用

我们都知道创建一个线程可以继承Thread类或者实现Runnable接口,实际Thread类就是实现了Runnable接口. 到今天才明白后端线程的作用:我们可以开启线程去执行一些比较耗时的操作,类似于前台的ajax异步操作,比如说用户上传一个大的文件,我们可以获取到文件之后开启一个线程去操作该文件,但是可以提前将结果返回去,如果同步处理有可能太耗时,影响系统可用性. 1.new Thread的弊端 原生的开启线程执行异步任务的方式: new Thread(new Runnable() { @O

【python】Threadpool线程池任务终止简单示例

需求 加入我们需要处理一串个位数(0~9),奇数时需要循环打印它:偶数则等待对应时长并完成所有任务:0则是错误,但不需要终止任务,可以自定义一些处理. 关键点 定义func函数处理需求 callback处理返回结果,只有偶数和0返回:奇数会一直执行:要控制线程池状态,则需要针对偶数和0时抛出异常,并捕获异常处理. threadpool定义线程池并发 实现 # -*- coding: utf-8 -*-from threadpool import makeRequests, ThreadPooli

QT 线程池 + TCP 小试(一)线程池的简单实现

*免分资源链接点击打开链接http://download.csdn.net/detail/goldenhawking/4492378 很久以前做过ACE + MFC/QT 的中轻量级线程池应用,大概就是利用线程池执行客户机上的运算需求,将结果返回.ACE是跨平台重量级的通信中间件,与常见的应用程序框架需要精心契合,才能不出问题.最近想到既然QT框架本身就已经具有各类功能,何不玩一玩呢,那就开搞!这个实验的代码可以从我的资源内下载. 第一步打算实现的模式,我们需要一个设置为CPU核心数的线程池,这

十五篇、自定义线程池之简单的线程池

1 二. #!/usr/bin/env python 2 #-*- coding:utf-8 -*- 3 import threading 4 import queue 5 import time 6 7 class ThreadPool(object): 8 def __init__(self,max_num = 20): 9 self.queue = queue.Queue(max_num) #创建一个最大长度为20的队列 10 for i in range(max_num): #往队列里面