java_day19_线程组、线程池、定时器、InetAddress、网络编程、设计模式

一、线程组：

线程组：将属于同一类的线程划分到同一组中，可以直接对线程组进行设置。ThreadGroup构造方法：ThreadGroup(String name) 构造一个新的线程组。

代码案例：

class MyThread1 extends Thread{public MyThread1() {}public MyThread1(ThreadGroup group, String name) {super(group, name);}@Overridepublic void run() {System.out.println("这是帅哥线程");}
}public class ThreadGroupDemo1 {public static void main(String[] args) {//创建一个线程组，组名叫做帅哥组ThreadGroup tg1 = new ThreadGroup("帅哥组");ThreadGroup tg2 = new ThreadGroup("美女组");//创建两个线程对象，分配到线程组中
//        MyThread1 t1 = new MyThread1();
//        t1.setName("李刚");//Thread(ThreadGroup group, String name)//分配一个新的 Thread对象。MyThread1 t1 = new MyThread1(tg1, "李刚");MyThread1 t2 = new MyThread1(tg1, "钱志强");MyThread1 t3 = new MyThread1(tg2, "李世博");MyThread1 t4 = new MyThread1(tg2, "杨珊珊");System.out.println(t1.getName()+"属于 "+t1.getThreadGroup().getName());System.out.println(t2.getName()+"属于 "+t2.getThreadGroup().getName());System.out.println(t3.getName()+"属于 "+t3.getThreadGroup().getName());System.out.println(t4.getName()+"属于 "+t4.getThreadGroup().getName());//        t1.setDaemon(true);
//        t2.setDaemon(true);tg1.setDaemon(true);}
}

二、线程池

线程池：ThreadPoolExecutors:static ExecutorService newCachedThreadPool() 创建一个根据需要创建新线程的线程池，但在可用时将重新使用以前构造的线程。static ExecutorService newFixedThreadPool(int nThreads) 创建一个线程池，该线程池重用固定数量的从共享无界队列中运行的线程。static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 创建一个线程池，可以调度命令在给定的延迟之后运行，或定期执行。

代码案例：

class MyRunnable implements Runnable {@Overridepublic void run() {for (int i = 1; i <= 100; i++) {System.out.println(Thread.currentThread().getName() + " - " + i);}}
}class MyCallable implements Callable{@Overridepublic Object call() throws Exception {for (int i = 1; i <= 100; i++) {System.out.println(Thread.currentThread().getName() + " - " + i);}return null;}
}public class ThreadPoolDemo1 {public static void main(String[] args) {//创建一个固定大小的线程池ExecutorService pool = Executors.newFixedThreadPool(2);//Future<?> submit(Runnable task);
//        pool.submit(new MyRunnable());
//        pool.submit(new MyRunnable());
//        pool.submit(new MyRunnable());// <T> Future<T> submit(Callable<T> task);
//        pool.submit(new MyCallable());
//        pool.submit(new MyCallable());pool.submit(new Callable<Object>() {@Overridepublic Object call() throws Exception {for (int i = 1; i <= 100; i++) {System.out.println(Thread.currentThread().getName() + " - " + i);}return null;}});//        pool.submit(new Callable<Object>() {
//            @Override
//            public Object call() throws Exception {
//                //....
//                return null;
//            }
//        });//关闭线程池pool.shutdown();}
}

三、定时器

定时器：Timer
定时任务：TimerTask

代码案例：

public class TimerDemo1 {public static void main(String[] args) {//创建一个定时器Timer timer = new Timer();//public void schedule(TimerTask task, long delay) 延迟多少毫秒后执行定义任务timer.schedule(new MyTask(timer), 5000);//public void schedule(TimerTask task,long delay,long period) 延迟delay毫秒后执行定义任务，后续每间隔period毫米执行一次timer.schedule(new MyTask(timer), 5000,2000);}
}class MyTask extends TimerTask{Timer timer;public MyTask(Timer timer) {this.timer = timer;}@Overridepublic void run() {System.out.println("砰！爆炸了.....");
//        timer.cancel();}
}

四、InetAddress

InetAddress: java提供的类，用于表示ip地址

public class InetAddressDemo1 {public static void main(String[] args) throws Exception {// static InetAddress getLocalHost()//返回本地主机的地址。InetAddress ip1 = InetAddress.getLocalHost();System.out.println(ip1);// String getHostName()//获取此IP地址的主机名。String hostName = ip1.getHostName();//String getHostName()//获取此IP地址的主机名。String ip = ip1.getHostAddress();System.out.println("主机名： "+hostName+", ip地址："+ip);}
}

五、网络编程

1、UDP协议

发送端

1:建立udp的socket服务
2:将要发送的数据封装成数据包
3:通过udp的socket服务,将数据包发送出
4:关闭资源

public class SendDemo1 {public static void main(String[] args) throws Exception{// 1:建立udp的socket服务// DatagramSocket//DatagramSocket()//构造数据报套接字并将其绑定到本地主机上的任何可用端口。DatagramSocket socket = new DatagramSocket();//创建键盘录入对象Scanner sc = new Scanner(System.in);while (true){System.out.print("请输入要发送的内容：");String info = sc.nextLine();// 2:将要发送的数据封装成数据包 DatagramPacket//DatagramPacket(byte[] buf, int length, InetAddress address, int port)//构造用于发送长度的分组的数据报包 length指定主机上到指定的端口号。byte[] bytes = info.getBytes();int length = bytes.length;InetAddress address = InetAddress.getByName("192.168.22.15");DatagramPacket packet = new DatagramPacket(bytes, length, address, 10086);// 3:通过udp的socket服务,将数据包发送出//public void send(DatagramPacket p)socket.send(packet);if("886".equals(info)){break;}}// 4:关闭资源socket.close();}
}

接收端

1:建立udp的socket服务.
2:通过receive方法接收数据
3:将收到的数据存储到数据包对象中
4:通过数据包对象的功能来完成对接收到数据进行解析.
5:可以对资源进行关闭

public class ReceiveDemo1 {public static void main(String[] args) throws Exception{// 1:建立udp的socket服务DatagramSocket socket = new DatagramSocket(10086);System.out.println("=================== 欢迎来到32期大群聊 =======================");while (true){// 2:通过receive方法接收数据//public synchronized void receive(DatagramPacket p)byte[] bytes = new byte[1024];DatagramPacket packet = new DatagramPacket(bytes, bytes.length);socket.receive(packet);//4:通过数据包对象的功能来完成对接收到数据进行解析.byte[] data = packet.getData();int length = packet.getLength();String info = new String(data, 0, length);InetAddress address = packet.getAddress();String hostName = address.getHostName();BufferedWriter bw = new BufferedWriter(new FileWriter("java/src/com/shujia/day19/recode/" + hostName + ".txt",true));if("886".equals(info)){System.out.println("----------- 提示线 -------------");System.out.println(hostName+" 用户已离开群聊.....");System.out.println("----------- 提示线 -------------");
//                break;}else {String time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());System.out.println(time);System.out.println(hostName+ "："+info);bw.write(time);bw.newLine();bw.write(info);bw.newLine();bw.flush();System.out.println();}}// 5:可以对资源进行关闭
//        socket.close();}
}

2、TCP协议

客户端

1:建立客户端的Socket服务,并明确要连接的服务器。
2:如果连接建立成功,就表明,已经建立了数据传输的通道.就可以在该通道通过IO进行数据的读取和写入.该通道称为Socket流,Socket流中既有读取流,也有写入流.
3:通过Socket对象的方法,可以获取这两个流
4:通过流的对象可以对数据进行传输
5:如果传输数据完毕,关闭资源

public class ClientDemo1 {public static void main(String[] args) throws Exception{// 1:建立客户端的Socket服务,并明确要连接的服务器。//Socket(String host, int port)//创建流套接字并将其连接到指定主机上的指定端口号。Socket socket = new Socket("192.168.22.15", 12345);Scanner sc = new Scanner(System.in);// 3:通过Socket对象的方法,可以获取这两个流//获取通道中的输出流，将数据发送给服务端OutputStream outputStream = socket.getOutputStream();//获取通道中的输入流InputStream inputStream = socket.getInputStream();while (true){System.out.print("请输入要发送的内容：");String info = sc.nextLine();if("886".equals(info)){break;}// 4:通过流的对象可以对数据进行传输outputStream.write(info.getBytes());outputStream.flush(); // 来自于通道中的类byte[] bytes = new byte[1024];int length = inputStream.read(bytes);String s = new String(bytes, 0, length);System.out.println(s);}// 5:如果传输数据完毕,关闭资源
//        outputStream.close();socket.close();}
}

服务端

1:建立服务器端的socket服务，需要一个端口
2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信
3:通过客户端的获取流对象的方法,读取数据或者写入数据
4:如果服务完成,需要关闭客户端,然后关闭服务器，但是,一般会关闭客户端,不会关闭服务器,因为服务端是一直提供服务的

public class ServerDemo1 {public static void main(String[] args){try {// 1:建立服务器端的socket服务，需要一个端口//ServerSocket(int port)//创建绑定到指定端口的服务器套接字。ServerSocket ss = new ServerSocket(12345);// 2:服务端没有直接流的操作,而是通过accept方法获取客户端对象，在通过获取到的客户端对象的流和客户端进行通信Socket socket = ss.accept();while (true){InetAddress inetAddress = socket.getInetAddress();String hostName = inetAddress.getHostName();// 3:通过客户端的获取流对象的方法,读取数据或者写入数据// 获取通道中的输入流InputStream inputStream = socket.getInputStream();byte[] bytes = new byte[1024];int length = inputStream.read(bytes);String s = new String(bytes, 0, length);System.out.println(hostName+": "+s);// 获取通道中的输出流OutputStream outputStream = socket.getOutputStream();outputStream.write("服务器已接收！".getBytes());outputStream.flush();}}catch (Exception e){System.out.println("用户已退出。。。");}}
}

六、设计模式

设计模式：创建型模式简单工厂模式工厂方法模式单例模式行为型模式结构型模式

1、简单工厂模式

public abstract class Animal {public abstract void eat();public abstract void sleep();
}

  public class Cat extends Animal{@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void sleep() {System.out.println("猫蜷着睡");}}

public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃肉");}@Overridepublic void sleep() {System.out.println("狗侧着睡");}
}

public class AnimalFactory {private AnimalFactory() {}public static Animal createAnimal(String name){if("dog".equals(name)){return new Dog();}else if("cat".equals(name)){return new Cat();}else {System.out.println("没有该动物");return null;}}
}

public class FactoryDemo1 {public static void main(String[] args) {//养一只狗Animal d1 = AnimalFactory.createAnimal("dog");//养一只猫Animal c1 = AnimalFactory.createAnimal("cat");}
}

2、工厂方法模式

public abstract class Animal {public abstract void eat();public abstract void sleep();
}

public class Cat extends Animal {@Overridepublic void eat() {System.out.println("猫吃鱼");}@Overridepublic void sleep() {System.out.println("猫蜷着睡");}
}

public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃肉");}@Overridepublic void sleep() {System.out.println("狗侧着睡");}
}

public abstract class AnimalFactory {public abstract Animal createAnimal();
}

public class CatFactory extends AnimalFactory{@Overridepublic Animal createAnimal() {return new Cat();}
}

public class DogFactory extends AnimalFactory{@Overridepublic Animal createAnimal() {return new Dog();}
}

public class FactoryDemo1 {public static void main(String[] args) {DogFactory dogFactory = new DogFactory();CatFactory catFactory = new CatFactory();//        //养一只狗
//        Animal d1 = AnimalFactory.createAnimal("dog");Animal d1 = dogFactory.createAnimal();Animal d2 = dogFactory.createAnimal();//        //养一只猫
//        Animal c1 = AnimalFactory.createAnimal("cat");Animal c1 = catFactory.createAnimal();Animal c2 = catFactory.createAnimal();}
}

3、单例模式

单例模式：在整个java程序运行期间，内存中某一个对象有且仅只能有一个。笔试1. 饿汉式 工作开发中2. 懒汉式 面试的时候说，可能会涉及线程安全的问题。

饿汉式

public class Student1 {private static Student1 student1 = new Student1();private Student1(){}public static Student1 getStudent1(){return student1;}
}

懒汉式

public class Student2 {private static Student2 student2;private Student2(){}public synchronized static Student2 getStudent2(){if(student2==null){// t1 , t2, t3student2 = new Student2();}return student2;}
}