java18 任务调度

简介:

复制代码

任务调度;
Timer类,
/**
    了解
  Timer() 
  schedule(TimerTask task, Date time) 
  schedule(TimerTask task, Date firstTime, long period) 
  自学 quartz
 */
public class TimeDemo01 {
    public static void main(String[] args) {
        Timer timer =new Timer();
        timer.schedule(
            new TimerTask(){//TimerTask是一个抽象类需要创建它的子类,重写run方法
                @Override
                public void run() {
                    System.out.println("so easy....");
                }
            }, 
            new Date(System.currentTimeMillis()+1000), 200
        );
    }

}

///public abstract class TimerTask implements Runnable,TimerTask是一个抽象类和线程类。
//void java.util.Timer.schedule(TimerTask task, Date firstTime, long period)。
//new Date(System.currentTimeMillis()+1000)表示一秒后。




多线程总结:
一、创建线程
1.继承Thread
2.实现Runnable
3.实现Callable
二、线程的状态
1.新生-start-就绪-运行-阻塞-终止
2.终止线程的方法(重点)
3.sleep方法
三、线程信息
1.Thread.currentThread()
2.
复制代码

 

复制代码
网络编程关注的是网络底层的交互。
一、网络:将不同区域的计算机连接到一起,分为:局域网、城域网、互联网。
二、地址:ip地址,确定网络上的一个绝对地址。
三、端口号(2个字节,0-65525共65536个):由于计算机上有很多程序,用于区分   计算机上的软件的。
   1.在同一个协议下,端口号不能重复。不同协议下tcp和udp下端口号可以重复。
   2.1024以下的不要使用,是操作系统预留的,例如80->http,21->ftp。
四、资源定位:url:统一资源定位符,uri:统一资源。uri只有资源,url不仅仅有   资源还有定位(L表示location)。
五、数据传输:  1.协议(一个约定,比如规定现在上课说话的语言,用的书籍,不然大家听不懂):tcp和udp协议,
   1.1 TCP协议:类似于电话,需要先建立连接。面向连接,点到点通信,完全可靠,效率相当低下。
   1.2 UDP:类似于短信,非面向连接,效率高,传输不可靠数据可能丢失。
   2.传输:  (jsp、servlet在网络分层中是应用层,传输层(TCP/UDP),网络层(IP),数据链路层是操作系统。应用层是建立在传输层和网络层之上的。)
   2.1 先封装:应用层数据进过一层一层的封装后传到物理链路层。
   2.2 后拆封:物理链路层的数据进过一层一层的拆封后传到应用层。
   
   
   
   
Java封装的类:(数据传输过程中里面还是流)
1.InnetAddress InetSocketAddress 
2.URL
3.TCP:ServerSocket Socket
4.UDP:DatagramSocket DatagramPacket

每个类都有构造器,只是访问权限不一样。


InetAddress类:
确定ip地址和域名解析(DNS,dns作用是将www.163.com转换为61.135.253.15),但是没有端口信息。
InetSocketAddress类:
包含端口,用于socket通信。


import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;
/**
 * 没有封装端口
 */
public class InetDemo01 {
    public static void main(String[] args) throws UnknownHostException{        
        //使用getLocalHost方法创建InetAddress对象
        InetAddress addr = InetAddress.getLocalHost();
        System.out.println(addr.getHostAddress());  //返回:192.168.1.100
        System.out.println(addr.getHostName());  //输出计算机名
        //根据域名得到InetAddress对象
        addr = InetAddress.getByName("www.163.com"); 
        System.out.println(addr.getHostAddress());  //返回 163服务器的ip:61.135.253.15
        System.out.println(addr.getHostName());  //输出:www.163.com    
        //根据ip得到InetAddress对象
        addr = InetAddress.getByName("61.135.253.15"); 
        System.out.println(addr.getHostAddress());  //返回 163服务器的ip:61.135.253.15
        System.out.println(addr.getHostName());  //输出ip而不是域名。如果这个IP地 址不存在或DNS服务器不允许进行IP地址和域名的映射,getHostName方法就直接返回这个IP地址。
    }
}




import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;

/**
 * 封装端口:在InetAddress基础上+端口
 */
public class InetSockeDemo01 {
    //    InetAddress是ip地址对象,
    //  InetSocketAddress包含ip地址和端口的对象
    public static void main(String[] args) throws UnknownHostException {
        InetSocketAddress  address = new InetSocketAddress("127.0.0.1",9999);//在本机开一个端口
        address = new InetSocketAddress(InetAddress.getByName("127.0.0.1"),9999);//这行和上面那行是一样的。
        System.out.println(address.getHostName());//WIN7U-20130526M
        System.out.println(address.getPort());//9999
        InetAddress addr =address.getAddress();    
        System.out.println(addr.getHostAddress());  //返回:地址,127.0.0.1
        System.out.println(addr.getHostName());  //输出计算机名,WIN7U-20130526M
    }
}

URI(Uniform resource identifier)统一资源标示符,用来唯一的标识一个资源。
URL(Uniform resource Locator)统一资源定位器,不仅仅表示一种资源还表示这个资源的位置。

URL由4部分组成:协议、存放资源的主机域名、资源文件名和端口号。(我们自己敲的url时会自动省略http协议和80端口,因为是默认的。)


URL类:.创建(绝对路径和相对路径构建)


import java.net.MalformedURLException;
import java.net.URL;
public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        //绝对路径构建
        URL url = new URL("http://www.baidu.com:80/index.html?uname=bjsxt");
        System.out.println("协议:"+url.getProtocol());//协议:http
        System.out.println("域名:"+url.getHost());//域名:www.baidu.com
        System.out.println("端口:"+url.getPort());//端口:80
        System.out.println("资源:"+url.getFile());//资源:/index.html?uname=bjsxt
        System.out.println("相对路径:"+url.getPath());//相对路径:/index.html
        System.out.println("锚点:"+url.getRef()); //锚点:null
        System.out.println("参数:"+url.getQuery());//?参数 :存在锚点  返回null ,不存在,返回正确,参数:uname=bjsxt

        
         //相对路径构建
        url = new URL("http://www.baidu.com:80/a/");
        url = new URL(url,"b.txt");
        System.out.println(url.toString());//http://www.baidu.com:80/a/b.txt
        
    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;

/**
 * 获取资源:源代码
 */
public class URLDemo02 {
    public static void main(String[] args) throws IOException {
        URL url = new URL("http://www.baidu.com"); //主页 默认资源
        
        //获取资源 网络流
        /*
        InputStream is =url.openStream(); 
        byte[] flush = new byte[1024];
        int len =0;
        while(-1!=(len=is.read(flush))){//每次读取1024字节到flush数组,len表示真实读取进flush的字节长度。
            System.out.println(new String(flush,0,len));
        }
        is.close();
        乱码的愿意1.编码,2.字节数不够。*/
        
        BufferedReader  br = 
                new BufferedReader(new InputStreamReader(url.openStream(),"utf-8"));//网页utf-8编码,所以这里读进br也要utf-8
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("baidu2.html"),"utf-8"));//写入到文件baidu2.html也要utf-8,baidu2.html在工程目录下。
        
        String msg =null;
        while((msg=br.readLine())!=null){//读取进br
            //System.out.println(msg);
            bw.append(msg);//写入到文件baidu2.html
            bw.newLine();
        }
        bw.flush();
        
        bw.close();//close一定会flush()
        br.close();
    }
}



UDP通信:以数据为中心,不安全,非面向连接,数据可能丢失,效率高。
一、类:DatagramSocket DatagramPacket.
1.客户端
1.1 创建客户端 Datagramsocket类 + 指定端口,
1.2 准备数据
1.3 打包 DatagramPacket + 服务器地址及端口
1.4 发送
1.5 释放资源
2.服务器端
2.1 创建服务端 Datagramsocket类 + 指定端口,
2.2 准备接收的容器 (字节数组) 封装DatagramPacket
2.3 接收数据
2.4 分析
2.5 释放资源

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * 服务端
 * 1、创建服务端 +端口
 * 2、准备接受容器
 * 3、封装成 包
 * 4、接受数据
 * 5、分析数据  
 * 6、释放
 */
public class MyServer {
    public static void main(String[] args) throws IOException {
        //1、创建服务端 +端口
        DatagramSocket server = new DatagramSocket(8888);
        //2、准备接受容器
        byte[] container = new byte[1024];
        //3、把这个容器封装成 包 DatagramPacket(byte[] buf, int length)         
        DatagramPacket packet =new DatagramPacket(container, container.length) ;
        //4、接受数据到packet
        server.receive(packet);
        //5、分析数据
        byte[] data =packet.getData();
        int len =packet.getLength();
        System.out.println(new String(data,0,len));
        //6、释放
        server.close();
    }
}



import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
/**
 * 客户端
 * 1、创建客户端 +端口
 * 2、准备数据
 * 3、打包(发送的地点 及端口)
 * 4、发送
 * 5、释放
 * 思考: 89.12  数据+类型
 * 
 * 即使服务器关闭了,运行客户端也不会报错,因为这是UDP。
 */
public class MyClient {
    public static void main(String[] args) throws IOException {
        //1、创建客户端 +端口
        DatagramSocket client = new DatagramSocket(6666);
        //2、准备数据
        String msg ="udp编程";
        byte[] data =msg.getBytes();
        //3、数据打包(发送的地点 及端口) DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",8888));
        //4、发送
        client.send(packet);
        //5、释放
        client.close();
    }
}



看网页也是一种流的传输,下载也是一种流。


import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * 服务端
 * 1、创建服务端 +端口
 * 2、准备接受容器
 * 3、封装成 包
 * 4、接受数据
 * 5、分析数据 字节数组-->double
 * 6、释放
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1、创建服务端 +端口
        DatagramSocket server = new DatagramSocket(8888);
        //2、准备接受容器
        byte[] container = new byte[1024];
        //3、封装成 包 DatagramPacket(byte[] buf, int length)         
        DatagramPacket packet =new DatagramPacket(container, container.length) ;
        //4、接受数据
        server.receive(packet);
        //5、分析数据
        double data =convert(packet.getData());
        System.out.println(data);
        //6、释放
        server.close();
    }
    /**
     * 字节数组 +Data 输入流
            字节数组转成double
     */
    public static double convert(byte[] data) throws IOException{
        DataInputStream dis =new DataInputStream(new ByteArrayInputStream(data));
        double num =dis.readDouble();
        dis.close();
        return num;
    }
}

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

/**
 * 客户端
 * 1、创建客户端 +端口
 * 2、准备数据   double -->字节数组   字节数组输出流
 * 3、打包(发送的地点 及端口)
 * 4、发送
 * 5、释放
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1、创建客户端 +端口
        DatagramSocket client = new DatagramSocket(6666);
        //2、准备数据
        double num =89.12;
        byte[] data =convert(num);
        //3、打包(发送的地点 及端口) DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",8888));
        //4、发送
        client.send(packet);
        //5、释放
        client.close();
    }
    
    /**
    double转成字节数组,DataOutputStream和DataInputStream是处理数据类型的。
     */
    public static byte[] convert(double num) throws IOException{
        byte[] data =null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos =new DataOutputStream(bos);
        dos.writeDouble(num);//把内存中的num(89.12)转成字节数组输出到容器bos,
        dos.flush();
        
        //获取数据
        data = bos.toByteArray();
        dos.close();        
        return data;
    }
}
UDP是数据里面去找服务器。


Socket通信:基于tcp协议,建立稳定连接的点对点通信,实时、快速、安全、占用系统资源多、效率相对低。
请求-相应模式:
    客户端:在网络通讯中,第一次主动发起通讯的程序称为客户端程序。
    服务器:第一次通讯中等待连接的程序称为服务器端程序。
Socket:发送TCP消息
ServerSocket:创建服务器


一、面向连接:请求-相应 Request-Response
二、服务器:ServerSocket,客户端Socket    客户端和服务端相当于有一个管道,这个管道就是socket,服务端的一个端口有可能有多个客户端来连接,每一个连接都有一个Socket。客户端和服务端都有一个端口,服务端的端口要指定,客户端的端口是自动分配的不需要指定。
(http协议底层的传输也是tcp协议,浏览器是一个基于tcp的客户端,只不过交互用的是http应用协议,tcp是http底层的协议。)

import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 必须先启动服务器 后连接
1、创建服务器  指定端口   ServerSocket(int port) 
2、接收客户端连接  
3、发送数据+接收数据
*/
public class Server {
    public static void main(String[] args) throws IOException {
        //1、创建服务器  指定端口   ServerSocket(int port) 
        ServerSocket server = new ServerSocket(8999);
        //2、接收客户端连接   阻塞式,Socket代表这条管道,这个管道也可以代表这个客户端。
        Socket socket =server.accept();//这行代码是服务端接收了客户端的连接,这就是服务端和客户端连接的那个管道,2者得到的是同一个管道。
        System.out.println("一个客户端建立连接");
        //3、发送数据到客户端
        String msg ="欢迎使用";
        //输出流
        /*
        BufferedWriter bw = new BufferedWriter(
                new OutputStreamWriter(     //OutputStreamWriter是一个转换流
                socket.getOutputStream()));
        
        bw.write(msg);
        bw.newLine();//在bw中加一个换行符,客户端读的时候br.readLine()是一行一行的读。
        bw.flush();*/
        
        //socket.getOutputStream()套接字的输出流,内部还是流。
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeUTF(msg);
        dos.flush();
    }
}



import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.net.UnknownHostException;

/**
 1、创建客户端   必须指定服务器+端口    此时就在连接
     Socket(String host, int port) 
 2、接收数据 +发送数据    
 */
public class Client {
    public static void main(String[] args) throws UnknownHostException, IOException {
        //1、创建客户端   必须指定服务器+端口    此时就在连接,这个客户端发送数据也是需要端口的只不过端口是系统自己分配(UDP的端口是要写的)。
        Socket client = new Socket("localhost",8999);//这里就和服务器建立了连接,这个Socket就是服务端和客户端连接的那个管道。
        //2、接收服务器来的数据
        /*
        BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
        String echo =br.readLine(); //阻塞式方法逐行的读取,br中要有行的结束符。
        System.out.println(echo);*/
        
        try {
            DataInputStream dis = new DataInputStream(client.getInputStream());
            String echo = dis.readUTF();
            System.out.println(echo);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

接收多个客户端:


import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
 必须先启动服务器 后连接
1、创建服务器  指定端口   ServerSocket(int port) 
2、接收客户端连接  
3、发送数据+接收数据
接收多个客户端
*/
public class MultiServer {
    public static void main(String[] args) throws IOException {
        //1、创建服务器  指定端口   ServerSocket(int port) 
        ServerSocket server = new ServerSocket(8888);
        //2、接收客户端连接   阻塞式
        while(true){ //死循环  一个accept()一个客户端
            Socket socket =server.accept();
            System.out.println("一个客户端建立连接");
            //3、发送数据
            String msg ="欢迎使用";
            //输出流
            
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            dos.writeUTF(msg);
            dos.flush();
            while(true){
                System.out.println("qqqqqqq\n");
            }
        }
    }
}
复制代码

 


本文转自农夫山泉别墅博客园博客,原文链接:http://www.cnblogs.com/yaowen/p/4833636.html,如需转载请自行联系原作者

相关实践学习
基于函数计算快速搭建Hexo博客系统
本场景介绍如何使用阿里云函数计算服务命令行工具快速搭建一个Hexo博客。
相关文章
|
1月前
|
运维 监控 Java
推荐一款好用的Java分布式任务调度框架!
推荐一款好用的Java分布式任务调度框架!
188 0
|
1月前
|
缓存 Java 调度
Java并发编程学习10-任务执行与Executor框架
【4月更文挑战第12天】本篇 重点讲解任务执行和 Executor框架的基础知识
36 4
Java并发编程学习10-任务执行与Executor框架
|
1月前
|
数据采集 安全 Java
Java并发编程学习12-任务取消(上)
【5月更文挑战第6天】本篇介绍了取消策略、线程中断、中断策略 和 响应中断的内容
39 4
Java并发编程学习12-任务取消(上)
|
1月前
|
存储 安全 Java
【深度挖掘Java并发编程底层源码】「底层技术原理体系」带你零基础认识和分析学习相关的异步任务提交机制FutureTask的底层原理
【深度挖掘Java并发编程底层源码】「底层技术原理体系」带你零基础认识和分析学习相关的异步任务提交机制FutureTask的底层原理
22 0
|
1月前
|
Java 流计算
这个错误信息来自于Java的ScheduledThreadPoolExecutor类,具体的原因是RejectedExecutionException,也就是任务被拒绝执行
【2月更文挑战第3天】这个错误信息来自于Java的ScheduledThreadPoolExecutor类,具体的原因是RejectedExecutionException,也就是任务被拒绝执行
47 2
|
1月前
|
缓存 Java 数据库
Java并发编程学习11-任务执行演示
【5月更文挑战第4天】本篇将结合任务执行和 Executor 框架的基础知识,演示一些不同版本的任务执行Demo,并且每个版本都实现了不同程度的并发性。
40 4
Java并发编程学习11-任务执行演示
|
1月前
|
安全 Java
【亮剑】Java中的`Future`接口代表异步计算结果,常与`ExecutorService`配合启动任务并获取结果
【4月更文挑战第30天】Java中的`Future`接口代表异步计算结果,常与`ExecutorService`配合启动任务并获取结果。`Future`接口提供`isDone()`、`get()`、`get(timeout, unit)`和`cancel(mayInterruptIfRunning)`等方法。`FutureTask`是`Future`的实现类,可作为`Runnable`执行并返回结果。
|
1月前
|
存储 安全 Java
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
Java多线程实战-从零手搓一个简易线程池(一)定义任务等待队列
|
1月前
|
缓存 监控 Java
Java并发编程:线程池与任务调度
【4月更文挑战第16天】Java并发编程中,线程池和任务调度是核心概念,能提升系统性能和响应速度。线程池通过重用线程减少创建销毁开销,如`ThreadPoolExecutor`和`ScheduledThreadPoolExecutor`。任务调度允许立即或延迟执行任务,具有灵活性。最佳实践包括合理配置线程池大小、避免过度使用线程、及时关闭线程池和处理异常。掌握这些能有效管理并发任务,避免性能瓶颈。
|
1月前
|
Java 关系型数据库 MySQL
Flink1.18.1和CDC2.4.1 本地没问题 提交任务到服务器 报错java.lang.NoClassDefFoundError: Could not initialize class io.debezium.connector.mysql.MySqlConnectorConfig
【2月更文挑战第33天】Flink1.18.1和CDC2.4.1 本地没问题 提交任务到服务器 报错java.lang.NoClassDefFoundError: Could not initialize class io.debezium.connector.mysql.MySqlConnectorConfig
123 2