首先介绍java定时器()有定时执行计划任务的功能,通过设定定时器的间隔时间,会自动在此间隔时间后执行预先安排好的任务(java.util. TimerTask)
由于我们希望当Web工程启动时，定时器能自动开始计时，这样在整个Web工程的生命期里,就会定时的执行任务,因此启动定时器的类不能是一般的类,此处用Servlet的监听器类来启动定时器,通过在配置文件里配置此监听器, 让其在工程启动时自动加载运行,存活期为整个Web工程生命期.
首先要去实现一个监听任务：

package com.sun.action;
 
import ;
 
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
 
/**
 * @author szy
 * @version 创建时间：2018-4-5 上午10:46:11
 *
 */
public class MyTimerTask implements ServletContextListener {
 
  private Timer timer = null;
  @Override
  public void contextDestroyed(ServletContextEvent event) {
    // TODO Auto-generated method stub
 
    timer.cancel();
     ().log("定时器销毁");
     
  }
 
  @Override
  public void contextInitialized(ServletContextEvent event) {
    // TODO Auto-generated method stub
 
    //在这里初始化监听器，在tomcat启动的时候监听器启动，可以在这里实现定时器功能
     timer = new Timer(true);
     ().log("定时器已启动");//添加日志，可在tomcat日志中查看到
     //调用exportHistoryBean，0表示任务无延迟，5*1000表示每隔5秒执行任务，60*60*1000表示一个小时；
     //(new SendEmail(()),0,24*60*60*1000);
     (new SendEmail(()),0,5*1000);
  }
}
　　然后实现监听的方法类：

package com.sun.action;
 
import Task;
 
import javax.servlet.ServletContext;
 
/**
 * @author szy
 * @version 创建时间：2018-4-5 上午10:50:00
 *
 */
public class SendEmail extends TimerTask {
 
  private ServletContext context = null;
  public SendEmail(ServletContext context)
  {
   this.context = context;
  }
   
  @Override
  public void run() {
    // TODO Auto-generated method stub
    System.out.println("您的邮件已发送，清注意查收");
  }
 
}
　　完成后，配置监听到里面去。

<?xml version="" encoding="UTF-8"?>
<web-app xmlns:xsi="" xmlns="" xmlns:web="/web-app_2_5.xsd" xsi:schemaLocation=" /web-app_3_0.xsd" version="">
 <display-name>TimerWeb</display-name>
 <welcome-file-list>
  <welcome-file>index.html</welcome-file>
  <welcome-file>index.htm</welcome-file>
  <welcome-file>index.jsp</welcome-file>
  <welcome-file>default.html</welcome-file>
  <welcome-file>default.htm</welcome-file>
  <welcome-file>default.jsp</welcome-file>
 </welcome-file-list>
 <listener>
  <listener-class>com.sun.action.MyTimerTask</listener-class>
 </listener>
</web-app>
　OK，通过Tomcat运行项目即可，可看到隔5s就会发送一条邮件，当然这里是模拟发送的邮件。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持脚本之家。

Java网络编程
网络编程是指编写运行在多个设备(计算机)的程序，这些设备都通过网络连接起来。
java.net包中J2SE的API包含有类和接口，它们提供低层次的通信细节。你可以直接使用这些类和接口，来专注于解决问题，而不用关注通信细节。
java.net包中提供了两种常见的网络协议的支持：
TCP： TCP是传输控制协议的缩写，它保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称TCP / IP。
UDP:UDP是用户数据报协议的缩写，一个无连接的协议。提供了应用程序之间要发送的数据的数据包。
Socket 编程
套接字使用TCP提供了两台计算机之间的通信机制。 客户端程序创建一个套接字，并尝试连接服务器的套接字。
当连接建立时，服务器会创建一个Socket对象。客户端和服务器现在可以通过对Socket对象的写入和读取来进行进行通信。
java.net.Socket类代表一个套接字，并且java.net.ServerSocket类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。
以下步骤在两台计算机之间使用套接字建立TCP连接时会出现：
服务器实例化一个ServerSocket对象，表示通过服务器上的端口通信。
服务器调用 ServerSocket类 的accept()方法，该方法将一直等待，直到客户端连接到服务器上给定的端口。
服务器正在等待时，一个客户端实例化一个Socket对象，指定服务器名称和端口号来请求连接。
Socket类的构造函数试图将客户端连接到指定的服务器和端口号。如果通信被建立，则在客户端创建一个Socket对象能够与服务器进行通信。
在服务器端，accept()方法返回服务器上一个新的socket引用，该socket连接到客户端的socket。
连接建立后，通过使用I/O流在进行通信。每一个socket都有一个输出流和一个输入流。客户端的输出流连接到服务器端的输入流，而客户端的输入流连接到服务器端的输出流。
TCP是一个双向的通信协议，因此数据可以通过两个数据流在同一时间发送.以下是一些类提供的一套完整的有用的方法来实现sockets。
ServerSocket 类的方法
服务器应用程序通过使用java.net.ServerSocket类以获取一个端口,并且侦听客户端请求。
ServerSocket类有四个构造方法：
ServerSocket类的常用方法：
Socket 类的方法
java.net.Socket类代表客户端和服务器都用来互相沟通的套接字。客户端要获取一个Socket对象通过实例化 ，而 服务器获得一个Socket对象则通过accept()方法的返回值。
Socket类有五个构造方法：
Socket类的常用方法：
InetAddress 类的方法:
Socket 客户端实例:
public class GreetingClient{ public static void main(String [] args) { String serverName = args[0]; int port = Integer.parseInt(args[1]); try { System.out.println("Connecting to " + serverName + " on port " + port); Socket client = new Socket(serverName, port); System.out.println("Just connected to " + client.getRemoteSocketAddress()); OutputStream outToServer = client.getOutputStream(); DataOutputStream out = new DataOutputStream(outToServer);  out.writeUTF("Hello from " + client.getLocalSocketAddress()); InputStream inFromServer = client.getInputStream(); DataInputStream in = new DataInputStream(inFromServer); System.out.println("Server says " + in.readUTF()); client.close(); }catch(IOException e) { e.printStackTrace(); } }}
Socket 服务端实例：
public class GreetingServer extends Thread{ private ServerSocket serverSocket;  public GreetingServer(int port) throws IOException { serverSocket = new ServerSocket(port); serverSocket.setSoTimeout(10000); } public void run() { while(true) { try { System.out.println("Waiting for client on port " + serverSocket.getLocalPort() + "..."); Socket server = serverSocket.accept(); System.out.println("Just connected to " + server.getRemoteSocketAddress()); DataInputStream in = new DataInputStream(server.getInputStream()); System.out.println(in.readUTF()); DataOutputStream out = new DataOutputStream(server.getOutputStream()); out.writeUTF("Thank you for connecting to " + server.getLocalSocketAddress() + "Goodbye!"); server.close(); }catch(SocketTimeoutException s) { System.out.println("Socket timed out!"); break; }catch(IOException e) { e.printStackTrace(); break; } } } public static void main(String [] args) { int port = Integer.parseInt(args[0]); try { Thread t = new GreetingServer(port); t.start(); }catch(IOException e) { e.printStackTrace(); } }}
实例结果：
Java 多线程编程
Java给多线程编程提供了内置的支持。一个多线程程序包含两个或多个能并发运行的部分。程序的每一部分都称作一个线程，并且每个线程定义了一个独立的执行路径。
多线程是多任务的一种特别的形式。多线程比多任务需要更小的开销。
这里定义和线程相关的另一个术语：进程：一个进程包括由操作系统分配的内存空间，包含一个或多个线程。一个线程不能独立的存在，它必须是进程的一部分。一个进程一直运行，直到所有的非守候线程都结束运行后才能结束。
多线程能满足程序员编写非常有效率的程序来达到充分利用CPU的目的，因为CPU的空闲时间能够保持在最低限度。
一个线程的生命周期
线程生命周期图
新建状态: 一个新产生的线程从新状态开始了它的生命周期。它保持这个状态直到程序start这个线程。
运行状态:当一个新状态的线程被start以后，线程就变成可运行状态，一个线程在此状态下被认为是开始执行其任务
就绪状态:当一个线程等待另外一个线程执行一个任务的时候，该线程就进入就绪状态。当另一个线程给就绪状态的线程发送信号时，该线程才重新切换到运行状态。
休眠状态: 由于一个线程的时间片用完了，该线程从运行状态进入休眠状态。当时间间隔到期或者等待的事件发生了，该状态的线程切换到运行状态。
终止状态: 一个运行状态的线程完成任务或者其他终止条件发生，该线程就切换到终止状态。
线程的优先级
每一个Java线程都有一个优先级，这样有助于操作系统确定线程的调度顺序。Java优先级在MIN_PRIORITY(1)和MAX_PRIORITY(10)之间的范围内。默认情况下，每一个线程都会分配一个优先级NORM_PRIORITY(5)。
具有较高优先级的线程对程序更重要，并且应该在低优先级的线程之前分配处理器时间。然而，线程优先级不能保证线程执行的顺序，而且非常依赖于平台。
Java提供了三种创建线程方法：
通过实现Runnable接口；
通过继承Thread类本身；
通过 Callable 和 Future 创建线程。
通过实现Runnable接口来创建线程
创建一个线程，最简单的方法是创建一个实现Runnable接口的类。
为了实现Runnable，一个类只需要执行一个方法调用run()，声明如下：
public void run()
你可以重写该方法，重要的是理解的run()可以调用其他方法，使用其他类，并声明变量，就像主线程一样。
在创建一个实现Runnable接口的类之后，你可以在类中实例化一个线程对象。
Thread定义了几个构造方法，下面的这个是我们经常使用的：
Thread(Runnable threadOb,String threadName);
这里，threadOb 是一个实现Runnable 接口的类的实例，并且 threadName指定新线程的名字。
新线程创建之后，你调用它的start()方法它才会运行。
void start();
Runnable创建线程实例：
通过继承Thread来创建线程
创建一个线程的第二种方法是创建一个新的类，该类继承Thread类，然后创建一个该类的实例。
继承类必须重写run()方法，该方法是新线程的入口点。它也必须调用start()方法才能执行。该方法尽管被列为一种多线程实现方式，但是本质上也是实现了 Runnable 接口的一个实例。
Thread实例：
Thread类的一些重要方法：
Thread类的静态方法：
通过 Callable 和 Future 创建线程
1. 创建 Callable 接口的实现类，并实现 call() 方法，该 call() 方法将作为线程执行体，并且有返回值。
2. 创建 Callable 实现类的实例，使用 FutureTask 类来包装 Callable 对象，该 FutureTask 对象封装了该 Callable 对象的 call() 方法的返回值。
3. 使用 FutureTask 对象作为 Thread 对象的 target 创建并启动新线程。
4. 调用 FutureTask 对象的 get() 方法来获得子线程执行结束后的返回值。
Callable 实例：
创建线程的三种方式的对比
1. 采用实现 Runnable、Callable 接口的方式创建多线程时，线程类只是实现了 Runnable 接口或 Callable 接口，还可以继承其他类。
2. 使用继承 Thread 类的方式创建多线程时，编写简单，如果需要访问当前线程，则无需使用 Thread.currentThread() 方法，直接使用 this 即可获得当前线程。
线程的几个主要概念
在多线程编程时，你需要了解以下几个概念：
线程同步
线程间通信
线程死锁
线程控制：挂起、停止和恢复
多线程的使用
有效利用多线程的关键是理解程序是并发执行而不是串行执行的。例如：程序中有两个子系统需要并发执行，这时候就需要利用多线程编程。
通过对多线程的使用，可以编写出非常高效的程序。不过请注意，如果你创建太多的线程，程序执行的效率实际上是降低了，而不是提升了。
请记住，上下文的切换开销也很重要，如果你创建了太多的线程，CPU花费在上下文的切换的时间将多于执行程序的时间！
Java 文档注释
Java只是三种注释方式。前两种分别是// 和/* */，第三种被称作说明注释，它以/** 开始，以 */结束。
说明注释允许你在程序中嵌入关于程序的信息。你可以使用javadoc工具软件来生成信息，并输出到HTML文件中。
说明注释，使你更加方便的记录你的程序的信息。
javadoc工具软件识别以下标签：
在开始的/**之后，第一行或几行是关于类、变量和方法的主要描述.
之后，你可以包含一个或多个何种各样的@标签。每一个@标签必须在一个新行的开始或者在一行的开始紧跟星号(*).
多个相同类型的标签应该放成一组。例如，如果你有三个@see标签，可以将它们一个接一个的放在一起。
好了，第二部分先到这里了。如果您喜欢，欢迎关注收藏转发。

在十几年前的 FreeBSD 中就存在 SO_REUSEPORT 参数来实现多个 socket 监听同一个端口，来提升服务器的负载，在 Linux 3.9 开始也引入了这个功能，下面就看一下例子。

 

#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdbool.h>
#include <arpa/inet.h>
#include <pthread.h>

void* do_work(void *arg)
{
    int *port = (int *) arg;

    int listen_socket = socket(AF_INET, SOCK_STREAM, 0);
    int one = 1;
    setsockopt(listen_socket, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one));

    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = INADDR_ANY;
    serv_addr.sin_port = htons(*port);

    int ret = bind(listen_socket, (struct sockaddr *) &serv_addr, sizeof(serv_addr)); 
    listen(listen_socket, 5);

    struct sockaddr_in cli_addr;
    memset(&cli_addr, 0, sizeof(cli_addr));
    int addr_length = sizeof(cli_addr);

    do
    {
        int cli_sock = accept(listen_socket, (struct sockaddr *) &cli_addr, (socklen_t *) &addr_length);
        close(cli_sock);
    } while (true);

    close(listen_socket);

    return 0;
}

int main(int ac, const char *av[])
{ 
    int port = atoi(av[1]);

    const int MAX_THREADS = 10;
    pthread_t tid[MAX_THREADS];
    for (int i = 0; i < MAX_THREADS; i++) {
        pthread_create(&tid[i], NULL, do_work, &port);
    }

    for (int i = 0; i < MAX_THREADS; i++) {
        pthread_join(tid[i], NULL);
    }
    return 0;
}

多进程监听多端口
# 多线程socket
# 程序监听两个端口，端口逻辑相同其中一个端口放在子进程下
# 每次请求会在产生一个进程处理请求
import SocketServer
from multiprocessing import Process
class MyServer(SocketServer.BaseRequestHandler):
def handle(self):
conn=self.request
conn.sendall('hello')
while True:
data=str(conn.recv(1024))
conn.sendall('server:'+data)
if __name__ == '__main__':
server1=SocketServer.ForkingTCPServer(('127.0.0.1',8000),MyServer)
server1.max_children=2
server2 = SocketServer.ForkingTCPServer(('127.0.0.1', 9000), MyServer)
server2.max_children = 2
p=Process(target=server2.serve_forever,args=())
p.start()
# server1需放在p.start后启动不然会阻塞进程，server2无法启动
server1.serve_forever()
p.join()
# print 'hah'
多线程把ForkingTCPServer换成ThreadingTCPServer去掉max_children配置即可
注：
坑！ 若使用多线程，因为无法配置线程数，并发太高会导致服务器产生很多进程也许会达到服务器显示的单个用户最多进程数，从而导致异常(linux 默认普通用户限制1024)
client
import  socket
ip=('127.0.0.1',8000)
sk=socket.socket()
sk.connect(ip)
sk.settimeout(10)
while True:
data=sk.recv(1024)
print('receive: %s',data)
inp=raw_input('please input:')
sk.sendall(bytes(inp))
if inp == 'exit':
break
sk.close()
[Linux] 多进程网络编程监听一个端口
SO_REUSEPORT支持多个进程或者线程绑定到同一端口 每个进程可以自己创建socket.bind.listen.accept相同的地址和端口,各自是独立平等的.让多进程监听同一个端口,各个进程中 ...
linux系统实现多个进程监听同一个端口
通过 fork 创建子进程的方式可以实现父子进程监听相同的端口. 方法:在绑定端口号(bind函数)之后,监听端口号之前(listen函数),用fork()函数生成子进程,这样子进程就可以克隆父进程, ...
linux: 获取监听指定端口的进程PID
在 linux 下经常需要杀死(重启)监听某端口的进程, 因此就写了一个小脚本, 通过 ss 命令获取监听制定端口的进程 PID, 然后通过 kill 命令结束掉进程: #!/bin/sh # set ...
普通用户从非80端口启动tomcat，通过端口转发监听80端口
linux下小于1024的端口都需要root去绑定. root权限启动tomcat是不明智的,可以使用非root权限启动tomcat监听8080端口,然后利用端口转发实现对80端口的监听. 端口转发: ...
【网络通信】服务器端Socket监听80端口，建立连接传输数据时也是使用的80端口么？
1. 服务器端Socket监听80端口,建立连接传输数据时也是使用的80端口么? 答:对.建立连接时服务器会分配一个新的Socket,但是用的源端口号还是80端口.套接字是由协议类型.源IP.目的IP ...
python hook监听事件
python hook监听事件 作者:vpoet mail:vpoet_sir@163.com # -*- coding: utf-8 -*- # # by oldj http://oldj.net/ ...
Oracle 11g RAC 环境下单实例非缺省监听及端口配置
如果在Oracle 11g RAC环境下使用dbca创建单实例数据库后,Oracle会自动将其注册到缺省的1521端口及监听器.大多数情况下我们使用的为非缺省监听器以及非缺省的监听端口.而且在Orac ...
剥开比原看代码03：比原是如何监听p2p端口的
作者:freewind 比原项目仓库: Github地址:https://github.com/Bytom/bytom Gitee地址:https://gitee.com/BytomBlockchai ...
如何查找php-fpm监听的端口
1. 找到php的安装位置.如: /usr/local/php-7.3.3 2. 进入安装目录下的etc/php-fpm.d目录,然后你会看到: 3. 打开www.conf,搜索listen关键字,你 ...
随机推荐
Mac OS环境下配置Myeclipse2015的经验
反复测试装了多次,现在把成功安装的方法陈列如下: 1. 相关的资源: (1)下载 myeclipse-2015-stable-2.0-offline-installer-macosx.dmg 链接:h ...
JSTL 核心标签库 使用(C标签)
JSTL 核心标签库标签共有13个,功能上分为4类: 1.表达式控制标签:out.set.remove.catch 2.流程控制标签:if.choose.when.otherwise 3.循环标签:f ...
DuiLib——第一篇UIManager
DUiLib 源码分析 --以UiLib 1.01版为分析目标 -------------------------------------------------------------------- ...
zabbix (2.0.6)  历史记录处乱码
1.首先备份数据库 mysqldump -uroot -p123456 zabbix > zabbix.sql 2.设置字符 sed -i 's/latin1/utf8/g' zabbix.sq ...
监控Tomcat并启动
#!/bin/sh export _JAVA_SR_SIGNUM= export JAVA_HOME=/usr/java/jdk1..0_11 export CATALINA_BASE=/home/c ...
【二】python内置类型
1.布尔类型 表示真假的类型(true和false) 数字 0.None,以及元素为空的容器类对象都可视作False,反之为 True. In [1]: bool(0) Out[1]: False I ...
hotplug/mdev机制
目录 hotplug/mdev机制 框架 kobject_uevent_env mdev_main make_device mdev.conf 配置文件学习 更改属性 @:创建设备节点之后执行命令 $ ...
SpringMVC知识点
一.SpringMVC 1.HelloWorld案例 ①步骤: 加jar包 在web.xml文件中配置DispatcherServlet 加入SpringMVC的配置文件 编写处理请求的处理器,并标识 ...
C++常备知识总结
1.extern表示是外部函数或外部变量,比如: 1.extern void add(int x,inty);表示该函数主体不在当前模块中,在另一个模块中(文件)2.extern int total; ...