java学习-day07

最新推荐文章于 2024-06-21 17:14:47 发布
最新推荐文章于 2024-06-21 17:14:47 发布
阅读量69 收藏
点赞数
分类专栏： java/数据库学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42608188/article/details/119981395
版权

个人曾经学习java的一些记录，仅供参考

java学习-day07

Socket(套接字)

Socket是由一个客户端和一个服务端组成。

TCP： 安全的协议，在通信的过程中，对方必须应答后才能通信（打电话）

UDP：广播的协议，只管发送数据，不管对方是否收到（短信、电台）

服务端

1、绑定IP地址 ： 使用默认就可以。

2、指定监听的端口号：需要指定一个未使用的PORT

import java.util.Scanner;

public class ScannerUtil {

    private static Scanner sc = new Scanner(System.in);

    public static String PUT(String message) {
        System.out.println(message);
        String str = sc.next();
        return str;
    }
    public static String PUT() {
        System.out.println("请输入:");
        String str = sc.next();
        return str;
    }

}

服务端代码：

public class MyServer {
    public static void main(String[] args) {
        int port = 9999;
        ServerSocket server = null;
        Socket socket = null;
        try {
            server = new ServerSocket(port);//绑定端口
            //开始监听 9999
            while (true) {
                System.out.println("开始监听....");
                socket = server.accept(); //socket 客户端和服务端之间通信的数据传输对象,数据都封装 socket 对象中
                System.out.println("接受到请求.....");

                //接受数据
                InputStream in = socket.getInputStream();
                InputStreamReader i2r = new InputStreamReader(in);
                BufferedReader reader = new BufferedReader(i2r);

                String msg = reader.readLine();
                System.out.println(msg);

                // 返回一个数据: 服务器向客户端写数据
                OutputStream out = socket.getOutputStream();
                OutputStreamWriter o2w = new OutputStreamWriter(out);
                BufferedWriter writer = new BufferedWriter(o2w);
                writer.write(ScannerUtil.PUT());
                writer.newLine();
                writer.flush();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
                server.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

客户端

指定连接的IP地址和端口号

public class MyClient {
    public static void main(String[] args) {

        Socket socket = null;

        try {
            while (true){
                //创建一个socket对象用来连接服务端，并放服务端发送数据
                socket = new Socket("localhost",9999);
                // 发送数据
                OutputStream out = socket.getOutputStream();
                OutputStreamWriter o2w = new OutputStreamWriter(out);
                BufferedWriter writer = new BufferedWriter(o2w);
                writer.write(ScannerUtil.PUT());
                writer.newLine();
                writer.flush();

                // 接受收据
                InputStream in = socket.getInputStream();
                InputStreamReader i2r = new InputStreamReader(in);
                BufferedReader reader = new BufferedReader(i2r);
                String msg = reader.readLine();
                System.out.println(msg);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

多线程

线程和进程

进程：单一顺序控制流（QQ，LOL）

线程：单一顺序控制流，是一个轻量级的进程

因为进程之间的通信，开销比较打，而我们在实际的开发过程中，很多场景需要通过线程来完成，线程的开销比较小。

如何创建多线程

创建线程和启动

public class Test {

    public static void main(String[] args) {
        // 程序在启动的时候会启动一个主线程main：老大
        //获取线程名称
        System.out.println(Thread.currentThread().getName());
        // 安排小弟做事：创建了一个子线程 自定义线程
        Runnable r = new MyRun();//创建了一个线程对象：小弟
        // 向小弟发送命令：去收保护费  => 启动线程
        // Thread 类提供了对线程的API
        Thread t = new Thread(r);
        //  向JVM发送了一个启动线程的指令
        t.start(); // 能看到 老大打王者去了... 在小弟收保护费之前执行 说明不是顺序的
        System.out.println("老大打王者去了...");
    }

}
// 生命了一个线程类
class MyRun implements Runnable{

    // run 方法程序员不能显示调用： JVM调用
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":小弟收保护费");
    }
}

总结：

1、当程序启动时候JVM会启动一个主线程：main

2、创建线程对象需要实现Runnable接口，重写run方法，在run方法中执行需要执行的业务

3、启动线程不是run方法，而是调用Thread类的start方法。Thread才是提供了对线程的操作

4、以上代码 老大打王者 可能会在小弟收保护费之前就执行了。说明不是顺序的

创建多线程

需要多个小弟收保护费：创建多线程

public class Test {
    public static void main(String[] args) {

        System.out.println(Thread.currentThread().getName()+"开始工作");
        // 安排多个小弟(3)去收保护费
        Runnable r1 = new MyRunnable();
        Runnable r2 = new MyRunnable();
        Runnable r3 = new MyRunnable();
        // 通过Thread 去启动线程
        Thread t1 = new Thread(r1,"小弟A"); // name是自定义线程名字
        Thread t2 = new Thread(r2,"小弟B");
        Thread t3 = new Thread(r3,"小弟C");

        // 分别启动3个小弟线程
        t1.start();
        t2.start();
        t3.start();

        System.out.println(Thread.currentThread().getName()+"工作结束");
    }
}

class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"收保护费");
    }
}

总结：

1、多个线程之前的执行顺序，程序员不可控。

2、要执行多线程，就需要创建多个线程对象。

线程的生命周期

public class Test {
    public static void main(String[] args) {

        // 生
        Runnable r = () -> {
            System.out.println(Thread.currentThread().getName()+"执行任务");
            // 完成任务会自动销毁 死
        };
        Thread t = new Thread(r,"子线程");
        // 启动线程
        t.start(); // 可运行 -> 运行
        try {
            // 让当前线程休眠10毫秒，确保子线程执行完毕
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 再启动
        t.start();

    }
}

总结：

线程的状态转换是线程控制的基础。线程状态总的可分为五大状态：分别是生、死、可运行、运行、等待/阻塞。
1、新状态：线程对象已经创建，还没有在其上调用 start()方法。
2、可运行状态： 当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当 start()方法调用
时，线程首先迚入可运行状态。在线程运行乊后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。
3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程迚入运行状态
的唯一一种方式。
4、等待/阻塞/睡眠状态 ： 这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种，其共同点是：线程
仍旧是活的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行状态。
5、死亡态：当线程的 run()方法完成时就认为它死去。 这个线程对象也许是活的，但是，它已经丌是一个单独执行
的线程。线程一旦死亡，就丌能复生。 如果在一个死去的线程上调用 start()方法，会抛出
java.lang.IllegalThreadStateException 异常。

PS：程序不可以主动去销毁线程，必须让线程自然销毁。否则会发送不可控的安全问题。

线程的调度

sleep

sleep: 休眠- 让出线程资源也就是CPU的资源，一定时间后，再次获取CPU资源

为了防止某一个线程长期占用资源，导致启动线程不能完成任务。

public class Test {
    public static void main(String[] args) {

        Thread t1 = new MyThread("A同学");
        Thread t2 = new MyThread("B同学");

        t1.start();
        t2.start();


    }
}

class MyThread extends Thread{

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"打电话"+i);
            try {
                // 强制当前线程让出CPU 1毫秒
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

yield: 让出线程资源也就是CPU的资源，一个时间芯片。

public class Test {
    public static void main(String[] args) {

        Thread t1 = new MyThread("A同学");
        Thread t2 = new MyThread("B同学");

        t1.start();
        t2.start();


    }
}

class MyThread extends Thread{

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+"打电话"+i);
            Thread.yield();
        }
    }
}

join: 加入一个线程，等待加入的线程执行完后再执行

public class Test {
    public static void main(String[] args) {
        MyThread1 t1 = new MyThread1("线程A");
        Thread t2 = new MyThread2("线程B");
        t1.setTarget(t2);
        t1.start();
    }
}

class MyThread1 extends Thread {

    private Thread target;

    // 可以通过这个构造函数执行当前线程的名称
    public MyThread1(String name) {
        super(name);
    }

    // 调用set方法传递线程对象（参数）
    public void setTarget(Thread target) {
        this.target = target;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + i);
            if (i == 5) {
                try {
                    // 加入了线程2 线程1 会等待线程2执行后重新执行 => 插队
                    target.start();
                    target.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

class MyThread2 extends Thread {
    // 可以通过这个构造函数执行当前线程的名称
    public MyThread2(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + i);
        }
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-zUJFQLZY-1630225372879)(imgs/952KE2SEPV3_8IMN$OVB06.png)]

死锁

/**
 * 线程死锁
 * 2线程2把锁（2个对象）以上才可能发生死锁
 * 一个线程希望获取锁A后再去获取锁B，另外一个线程希望获取锁B后再去获取锁A,这个时候有可能发生死锁
 * （线程1获取了锁A的同时线程2获取了锁B这个时候会发生死锁）
 */
public class Test {

    public static void main(String[] args) {


        new Thread("线程1") {
            @Override
            public void run() {
                synchronized ("A") {
                    System.out.println(Thread.currentThread().getName() + "获得锁A");
                    try {
                        // 等待线程2获取锁B
                        Thread.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    synchronized ("B") {
                        System.out.println(Thread.currentThread().getName() + "获得锁B");
                    }
                }
            }
        }.start();
        new Thread("线程2") {
            @Override
            public void run() {
                synchronized ("B") {
                    System.out.println(Thread.currentThread().getName() + "获得锁B");
                    synchronized ("A") {
                        System.out.println(Thread.currentThread().getName() + "获得锁A");
                    }
                }
            }
        }.start();
    }

}

如何避免死锁？？？

  1. 加锁顺序（线程按照一定的顺序加锁）
  2. 加锁时限（线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
  3. 死锁检测（用JDK的工具）
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

Lock

public class Test {
    public static void main(String[] args) {
        Lock lock = new ReentrantLock();
        MyRunnable1 r1 = new MyRunnable1();
        r1.setLock(lock);
        MyRunnable2 r2 = new MyRunnable2();
        r2.setLock(lock);

        Thread t1 = new Thread(r1, "线程A");
        Thread t2 = new Thread(r2, "线程B");

        t1.start();
        t2.start();

    }
}

class MyRunnable1 implements Runnable {

    private Lock lock;

    public void setLock(Lock lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        // 加锁
        lock.lock();
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        // 释放锁
        lock.unlock();
    }
}

class MyRunnable2 implements Runnable {

    private Lock lock;

    public void setLock(Lock lock) {
        this.lock = lock;
    }

    @Override
    public void run() {
        lock.lock(); // 加锁
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName());
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        lock.unlock();// 释放锁
    }
}

Lock和synchronized的区别

synchronized：当一个线程执行到synchronized的代码块或者方法的时候会自动持有该对象的锁。这种锁是隐式的。

Lock：是一个类，JDK提供的工具类，锁是显示的。更方便操作

线程池：

线程池是通过池化的技术，将已经创建的线程保存到一个集合中，当需要使用线程来完成任务的时候，直接从线程池中获取空闲的线程执行任务，执行完任务后将线程归还线程池。可以减少多线程创建的开销。

public class Test {
    public static void main(String[] args) {
        // 5个任务
        MyRunnable r1 = new MyRunnable();
        MyRunnable r2 = new MyRunnable();
        MyRunnable r3 = new MyRunnable();
        MyRunnable r4 = new MyRunnable();
        MyRunnable r5 = new MyRunnable();
        Set<Runnable> set = new HashSet<>();
        set.add(r1);
        set.add(r2);
        set.add(r3);
        set.add(r4);
        set.add(r5);

        // 线程池
        // 1.带缓冲的线程池
        // ExecutorService service = Executors.newCachedThreadPool();
        // 2.固定大小的线程池
        ExecutorService service = Executors.newFixedThreadPool(3);

        Iterator<Runnable> its = set.iterator();
        while (its.hasNext()) {
            service.submit(its.next());
        }
        // 关闭线程池
        service.shutdown();
    }
}

// 任务类
class MyRunnable implements Runnable {
    @Override
    public void run() {
        // 业务
        System.out.println(Thread.currentThread().getName()+":do...");
    }
}

Callable

/**
 * 创建线程的方法：
 * 1.实现Runnable接口
 * 2.继承Thread类
 * 3.实现Callable接口
 * 4.线程池
 */
public class Test {
    public static void main(String[] args) throws Exception {

        MyCall call = new MyCall();

        ExecutorService service = Executors.newFixedThreadPool(2);
        Future<String> submit = service.submit(call);
        String result = submit.get();
        System.out.println("返回值:" + result);
        service.shutdown();
    }
}

class MyCall implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("hello Callable");
        return "hello Callable";
    }
}

定时任务

/**
 * 定时任务
 */
public class Test {

    public static void main(String[] args) {

        // 1. Timer : 任务调度类
        // 2. TimerTask ： 任务类接口，这个接口是 Runnable 的子类

        // 定义任务
        TimerTask task = new Task();
        // 调度任务
        Timer timer = new Timer();

        timer.schedule(task,DateUtil.parse("2019-11-30 10:00:00"),1000);
    }
}
// 任务类
class Task extends TimerTask{
    @Override
    public void run() {
        // 打印当前系统时间
        System.out.println(new Date());
    }
}
dst_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA学习笔记- - - day 1
m0_71956038的博客
11-18 6万+
目录💕前言：作者是一名正在学习JAVA的初学者，每天分享自己的学习笔记，希望能和大家一起进步成长💕​编辑运算符(重要)运算符四则运算基本数据类型变量间的运算赋值运算符比较运算符逻辑运算符(重要)流程控制(重要)1.if2.if...else...3.if...else if...else4.switch 只能做等值判断5.三元运算符6.循环结构while 先判断在做循环do...while 先循环在做判断for循环break面向对象面向过程面向对象类的属性类的方法创建对象的内存结构局部变量成员变量匿名对
JAVA学习笔记- - - day 2
热门推荐
m0_71956038的博客
11-26 5万+
目录💕前言：作者是一名正在学习JAVA的初学者，每天分享自己的学习笔记，希望能和大家一起进步成长💕封装(重点)数组一维数组(重点)二维数组方法的重载(重点)this关键字（重点）构造器（重点）默认构造器有参构造器static关键字（重点）属性上(静态属性/变量)方法上（静态方法）静态代码块设计模式(重点)单例。
Java学习-Day03（运算符）
wanlaizhou的博客
03-29 4268
在java中取模的本质 a % b = a - a / b * b &&短路与: （开发常用） 前面的条件为false，后面的条件不执行不判断，效率高 &逻辑与: 前面的条件为false，后面的条件仍然会判断执行，效率低 ||短路或：（开发常用） 前面的条件为true，后面的条件不执行不判断，效率高 |逻辑或： 前面的条件为true，后面的条件仍然会判断执行，效率低 ！取反：T->F,F->T ^逻辑异或： 相同为真，不同为假 赋值运算符： = ， += ， -.
零基础学习Java----day06
weixin_59729254的博客
05-15 655
欢迎批评指正！！
零基础学习Java----day05
weixin_59729254的博客
05-12 567
欢迎批评指正，共同进步！！
【JAVA-Day39】Java Math类解析
沉淀、分享、成长，让自己和他人都能有所收获！
09-21 3万+
作为博主，我将带领大家一起探索Java中的Math类，揭开它的神秘面纱。我们将详细研究它的各种方法，以及如何在实际应用中使用它。让我们一起深入了解这个强大的数学工具！首先，让我们来深入了解一下Math类是什么。Math类是Java标准库中的一个非常重要的工具类，它提供了各种用于执行基本数学运算的静态方法。这些方法通常用于处理数字数据，执行各种常见的数学计算，包括但不限于算术运算、取绝对值、取整数、指数计算、三角函数、随机数生成等等。不同于许多其他Java类，你无需创建Math。
学习日志 -- Day02
zixuan226的博客
05-09 2421
java简介、编写规范、变量、数据类型
【JAVA-Day55】Java集合类HashTable解析
沉淀、分享、成长，让自己和他人都能有所收获！
10-30 2万+
在本篇技术博客中，作为博主，我将深入探讨Java中的Hashtable集合类，为你提供全面的了解。我们将从Hashtable的基本概念开始，逐步深入，讨论其内部工作原理、性能、线程安全性，以及在现代Java框架中的应用。还将探讨Hashtable的未来发展趋势和替代选择，以帮助你更好地应用这一重要工具。通过本文，我们对Java中的Hashtable集合类有了深入的了解。我们介绍了其基本概念、与HashMap的比较、内部工作原理、性能、线程安全性以及最佳实践。
【JAVA-Day52】深度解析 Java TreeSet 集合
沉淀、分享、成长，让自己和他人都能有所收获！
10-23 2万+
博主在本篇文章中将深入解析Java中的TreeSet集合，探讨其特性、应用场景以及性能优化。通过多级标题结构，将引领读者从初步认识TreeSet到最佳实践，最终挑战高质量的面试题，全方位、深度解析TreeSet在Java中的应用。
【JAVA-Day49】Java LinkedList集合详解
沉淀、分享、成长，让自己和他人都能有所收获！
10-22 2万+
欢迎来到我的技术博客，本篇文章将深入探讨Java中的LinkedList集合。我们将首先介绍LinkedList的基本概念和结构，然后逐一讨论其用法、应用场景以及性能比较。通过本文，您将全面了解Java中LinkedList的内部实现和工作原理，以及如何优化其性能。最后，我们将回顾所学内容并提供实际应用案例，帮助您成为Java LinkedList的高级用户。LinkedList是一种双向链表实现的集合，它以节点相互连接的方式存储数据，具有动态大小和高度灵活的特性。
Java学习day01-day15学习资料
04-05
自学Java的基本资料（资料来自黑马程序员免费提供），本人并无恶意，单纯分享。本资料对应黑马程序员Java从入门到起飞的上半部分的1-15天资料。希望能对你有帮助。如有侵权，请联系删除。
Java入门基础学习资料day07-08
10-22
day07【Scanner类、Random类、ArrayList类】 day08【String类、static关键字、Arrays类、Math类】 day09【继承、super、this、抽象类】 day10【接口、多态】 day11【final、权限、内部类、引用类型】 此课程全部...
java基础语法-day01
01-04
【Java基础语法-day01】 Java是一门广泛使用的高级编程语言，它由Sun Microsystems公司（现已被Oracle公司收购）于1995年发布。Java的设计目标是具有平台独立性，能够编写一次，到处运行。这得益于其跨平台的Java...
20天学会Java--day01-课程介绍、Java概述、IDEA、Java基础语法
04-06
1，全网最强，最实用Java入门课程。 2、讲解由浅到深，没有废话，在最短时间教会最实用技术。 3、采用一线大厂真实需求驱动知识的学习，更清楚，更高效，更实用 4、大量的案例实战，初学者可以边学边干，边干边学...
Java基础-day14每日作业卷1
08-08
【Java基础-day14每日作业卷1】涵盖了Java网络编程中的基本概念，主要涉及IP地址、端口号、InetAddress类、UDP和TCP协议以及相关的数据包处理类。以下是这些知识点的详细说明： 1. **IP地址**：Internet Protocol ...
数据结构与算法-差分数组及应用
qq_36115196的博客
06-20 789
差分数组： 其实差分数组是创建一个一个辅助数组，用来表示给定数组的变化，一般用来对数组进行区间修改的操作。
日常工作记录目录
与海
06-21 157
EasyExcel实现二维码下载与展示
Day43
m0_67496588的博客
06-20 1060
JSON，Ajax
Homebrew使用
最新发布
gghh2015的博客
06-21 259
具体参考：https://blog.csdn.net/m0_67402970/article/details/126434901。简介：https://www.jianshu.com/p/f4c9cf0733ea。2、查看安装路径：brew list maven。官网：https://brew.sh/
初学java 必备：JavaSE基础\day01-Java入门&IDEA&基础语法
05-07
通过系统学习day01-Java入门的知识，学习者将能够建立起对Java编程语言的基本理解和掌握，为将来更加深入和专业的学习打下坚实的基础。因此，对于初学者来说，day01-Java入门是一个必备的学习内容，也是学习Java编程...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值