第9章 线程常用操作方法

最新推荐文章于 2020-07-31 21:15:34 发布
最新推荐文章于 2020-07-31 21:15:34 发布
阅读量156 收藏
点赞数
文章标签： 多线程 Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35028612/article/details/79923404
版权

第9章 线程常用操作方法

本章目标：
  • 了解设置和取得线程名称
  • 了解线程的强制运行
  • 了解线程的休眠
  • 了解线程的礼让
  • 了解线程的中断操作

在多线程中所有的操作方法实际上都是从Thread类开始的，所有的操作基本上都在Thread类之中。
这里写图片描述

一、线程名称

在Thread类之中，可以通过getName()方法取得线程的名称，通过 setName()方法设置线程的名称。

线程的名称一般在启动线程前设置，但也允许为已经运行的线程设置名称。允许两个Thread对象有相同的名字，但为了清晰，应尽量避免这种情况的发生。

另外，如果程序并没有为线程指定名称，则系统会自动地为线程分配一个名称。

package com.java.线程常用操作方法;

public class ThreadNameDemo {
    public static void main(String[] args){
        MyThread mt = new MyThread();    //实例化Runnable子类对象
        new Thread(mt).start();    //系统自动设置线程名称
        new Thread(mt,"线程-A").start();    //手工设置线程名称
        new Thread(mt,"线程-B").start();    //手工设置线程名称
        new Thread(mt).start();    //系统自动设置线程名称
        new Thread(mt).start();    //系统自动设置线程名称
    }
}

/**
 * 实现Runnable接口
 * @author Creator
 *
 */
class MyThread implements Runnable{ 

    /**
     * 覆写run方法
     */
    public void run(){ 
        for(int i = 0; i < 3; i++)
            /*
             * 取得当前线程的名字
             */
            System.out.println(Thread.currentThread().getName()
                    +"运行, i = " + i);
    }
}

程序运行效果：

Thread-0运行, i = 0
Thread-0运行, i = 1
Thread-0运行, i = 2
线程-A运行, i = 0
线程-A运行, i = 1
线程-A运行, i = 2
线程-B运行, i = 0
Thread-1运行, i = 0
Thread-1运行, i = 1
Thread-1运行, i = 2
线程-B运行, i = 1
线程-B运行, i = 2
Thread-2运行, i = 0
Thread-2运行, i = 1
Thread-2运行, i = 2

从执行效果来看，指定的名称会自动出现，如果没有指定会发现线程使用自动编号的方式完成，按照Thread-0，Thread-1….依次编号。实际上在类中存在一个static属性，用于记录编号。

二、取得当前线程

程序可以通过currentThread()方法取得当前正在运行的线程对象。

package com.java.线程常用操作方法;

public class CurrentThreadDemo {
    public static void main(String[] args){
        MyThread02 mt = new MyThread02();    //实例化Runnable子类对象
        new Thread(mt,"线程").start();    //启动线程
        mt.run();      //直接调用run()方法
    }
}

/**
 * 实现Runnable接口
 * @author Creator
 *
 */
class MyThread02 implements Runnable{ 

    /**
     * 覆写run方法
     */
    public void run(){ 
        for(int i = 0; i < 3; i++)
            /*
             * 取得当前线程的名字
             */
            System.out.println(Thread.currentThread().getName()
                    +"运行, i = " + i);
    }
}

运行效果：

main运行, i = 0
main运行, i = 1
main运行, i = 2
线程运行, i = 0
线程运行, i = 1
线程运行, i = 2

此时发现，程序中由主方法直接通过线程对象调用里面的run()方法，所以输出的结果中包含了一个“main”，此线程就是由“mt.run()”产生的。因为调用此语句是由主方法完成的，也就是说实际上主方法本身也是一个线程——主线程。

问题，既然主方法都是以线程的形式出现的，那么JAVA运行时到底启动了多少个线程？

回答：至少启动了2个线程。

  • 从之前学习的知识来看，每当Java程序执行的时候，实际上都会启动一个JVM，每一个JVM实际上就是在操作系统中启动了一个进程。Java中本身具备了垃圾收集机制，所以Java运行时至少启动2个线程：主线程，GC（垃圾回收）。

三、判断线程是否启动

package com.java.线程常用操作方法;

public class ThreadAliveDemo {
    public static void main(String[] args){
        MyThreadAlive mt = new MyThreadAlive();    //实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");    //实例化Thread对象
        System.out.println("线程开始执行之前 --> " + t.isAlive());//判断是否启动
        t.start();  //启动线程
        System.out.println("线程开始执行之后 --> " + t.isAlive());//判断是否启动
        for(int i =0 ; i < 3; i++){
            System.out.println("main运行 --> " + i);
        }
        System.out.println("代码执行之后--> " + t.isAlive());//判断是否启动
    }
}

/**
 * 实现Runnable接口
 * @author Creator
 *
 */
class MyThreadAlive implements Runnable{ 

    /**
     * 覆写run方法
     */
    public void run(){ 
        for(int i = 0; i < 3; i++)
            /*
             * 取得当前线程的名字
             */
            System.out.println(Thread.currentThread().getName()
                    +"运行, i = " + i);
    }
}

运行效果：

线程开始执行之前 --> false
线程开始执行之后 --> true
main运行 --> 0
main运行 --> 1
main运行 --> 2
代码执行之后--> true
线程运行, i = 0
线程运行, i = 1
线程运行, i = 2

四、线程的强制运行

在线程操作中，可以使用join()方法让一个线程强制运行，线程强制运行期间，其他线程无法运行，必须等待此线程完成之后才可以继续运行。

package com.java.线程常用操作方法;

public class ThreadJoinDemo {
    public static void main(String[] args){
        MyThreadJoin mt = new MyThreadJoin();    //实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");    //实例化Thread对象
        t.start();  //启动线程
        for(int i =0 ; i < 50; i++){
            if(i > 10)
                try {
                    t.join();//线程强制运行
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }  
            System.out.println("Main线程运行 --> " + i);
        }
    }
}

/**
 * 实现Runnable接口
 * @author Creator
 *
 */
class MyThreadJoin implements Runnable{ 

    /**
     * 覆写run方法
     */
    public void run(){ 
        for(int i = 0; i < 50; i++)
            /*
             * 取得当前线程的名字
             */
            System.out.println(Thread.currentThread().getName()
                    +"运行, i = " + i);
    }
}

运行效果：

Main线程运行 --> 0
Main线程运行 --> 1
Main线程运行 --> 2
Main线程运行 --> 3
Main线程运行 --> 4
Main线程运行 --> 5
Main线程运行 --> 6
Main线程运行 --> 7
Main线程运行 --> 8
Main线程运行 --> 9
Main线程运行 --> 10
线程运行, i = 0
线程运行, i = 1
线程运行, i = 2
线程运行, i = 3
线程运行, i = 4
线程运行, i = 5
线程运行, i = 6
线程运行, i = 7
线程运行, i = 8
线程运行, i = 9
线程运行, i = 10
线程运行, i = 11
线程运行, i = 12
线程运行, i = 13
线程运行, i = 14
线程运行, i = 15
线程运行, i = 16
线程运行, i = 17
线程运行, i = 18
线程运行, i = 19
线程运行, i = 20
线程运行, i = 21
线程运行, i = 22
线程运行, i = 23
线程运行, i = 24
线程运行, i = 25
线程运行, i = 26
线程运行, i = 27
线程运行, i = 28
线程运行, i = 29
线程运行, i = 30
线程运行, i = 31
线程运行, i = 32
线程运行, i = 33
线程运行, i = 34
线程运行, i = 35
线程运行, i = 36
线程运行, i = 37
线程运行, i = 38
线程运行, i = 39
线程运行, i = 40
线程运行, i = 41
线程运行, i = 42
线程运行, i = 43
线程运行, i = 44
线程运行, i = 45
线程运行, i = 46
线程运行, i = 47
线程运行, i = 48
线程运行, i = 49
Main线程运行 --> 11
Main线程运行 --> 12
Main线程运行 --> 13
Main线程运行 --> 14
Main线程运行 --> 15
Main线程运行 --> 16
Main线程运行 --> 17
Main线程运行 --> 18
Main线程运行 --> 19
Main线程运行 --> 20
Main线程运行 --> 21
Main线程运行 --> 22
Main线程运行 --> 23
Main线程运行 --> 24
Main线程运行 --> 25
Main线程运行 --> 26
Main线程运行 --> 27
Main线程运行 --> 28
Main线程运行 --> 29
Main线程运行 --> 30
Main线程运行 --> 31
Main线程运行 --> 32
Main线程运行 --> 33
Main线程运行 --> 34
Main线程运行 --> 35
Main线程运行 --> 36
Main线程运行 --> 37
Main线程运行 --> 38
Main线程运行 --> 39
Main线程运行 --> 40
Main线程运行 --> 41
Main线程运行 --> 42
Main线程运行 --> 43
Main线程运行 --> 44
Main线程运行 --> 45
Main线程运行 --> 46
Main线程运行 --> 47
Main线程运行 --> 48
Main线程运行 --> 49

五、线程的休眠

使用休眠可以让线程暂停执行。直接使用Thread.sleep()方法。

package com.java.线程常用操作方法;

public class ThreadSleepDemo {
    public static void main(String[] args){
        MyThreadSleep mt = new MyThreadSleep();    //实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");    //实例化Thread对象
        t.start();  //启动线程
    }
}

/**
 * 实现Runnable接口
 * @author Creator
 *
 */
class MyThreadSleep implements Runnable{ 

    /**
     * 覆写run方法
     */
    public void run(){ 
        for(int i = 0; i < 50; i++){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            /*
             * 取得当前线程的名字
             */
            System.out.println(Thread.currentThread().getName()
                    +"运行, i = " + i);
        }
    }
}

运行效果：
这里写图片描述

六、线程的中断

一个线程可以被另外一个线程中断其操作的状态，使用interrupt()方法完成。

package com.java.线程常用操作方法;

public class ThreadInterruptDemo {
    public static void main(String[] args){
        MyThreadSInterrupt mt = new MyThreadSInterrupt();    //实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");    //实例化Thread对象
        t.start();  //启动线程
        try {
            Thread.sleep(2000); //线程休眠2s
        } catch (InterruptedException e) {
        }

        t.interrupt(); //中断线程执行
    }
}

/**
 * 实现Runnable接口
 * @author Creator
 *
 */
class MyThreadSInterrupt implements Runnable{ 

    /**
     * 覆写run方法
     */
    public void run(){ 
        System.out.println("1、进入run()方法");
        try {
            Thread.sleep(10000); //线程休眠10s
            System.out.println("2、已经完成了休眠");
        } catch (InterruptedException e) {
            System.out.println("3、休眠被终止");
            return;  //返回调用处
        }
        System.out.println("4、 run()方法正常结束");
    }
}

运行效果：

1、进入run()方法
3、休眠被终止

七、后台线程

在Java中，只要一个程序没有执行完（一个线程在运行），则整个Java的进程不会消失。所以，此时可以设置一个后台线程，这样即使Java进程结束了，此后台线程依然会继续执行。直接使用setDaemon()方法。

package com.java.线程常用操作方法;

public class ThreadDaemonDemo {
    public static void main(String[] args){
        MyThreadSDaemon mt = new MyThreadSDaemon();    //实例化Runnable子类对象
        Thread t = new Thread(mt,"线程");    //实例化Thread对象
        t.setDaemon(true); //此线程在后台运行
        t.start();  //启动线程
    }
}

/**
 * 实现Runnable接口
 * @author Creator
 *
 */
class MyThreadSDaemon implements Runnable{ 

    /**
     * 覆写run方法
     */
    public void run(){ 
        while(true){
            System.out.println(Thread.currentThread().getName());
        }
    }
}

八、线程的优先级

这里写图片描述

package com.java.线程常用操作方法;

public class ThreadPriorityDemo {
    public static void main(String[] args){
        Thread t1 = new Thread(new MyThreadPriority(),"线程A"); //实例化线程对象
        Thread t2 = new Thread(new MyThreadPriority(),"线程B"); //实例化线程对象
        Thread t3 = new Thread(new MyThreadPriority(),"线程C"); //实例化线程对象
        t1.setPriority(Thread.MIN_PRIORITY);  //优先级最低
        t2.setPriority(Thread.MAX_PRIORITY);  //优先级最高
        t3.setPriority(Thread.NORM_PRIORITY); //普通优先级
        t1.start();  //启动线程
        t2.start();  //启动线程
        t3.start();  //启动线程
    }
}

/**
 * 实现Runnable接口
 * @author Creator
 *
 */
class MyThreadPriority implements Runnable{ 

    /**
     * 覆写run方法
     */
    public void run(){ 
        for(int i = 0; i < 5; i++){
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            /*
             * 取得当前线程的名字
             */
            System.out.println(Thread.currentThread().getName()
                    +"运行, i = " + i);
        }
    }
}

运行效果：

线程B运行, i = 0
线程A运行, i = 0
线程C运行, i = 0
线程B运行, i = 1
线程C运行, i = 1
线程A运行, i = 1
线程B运行, i = 2
线程C运行, i = 2
线程A运行, i = 2
线程B运行, i = 3
线程C运行, i = 3
线程A运行, i = 3
线程B运行, i = 4
线程C运行, i = 4
线程A运行, i = 4
飞过秋天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第10章 多线程.docx
12-31
5. **线程常用方法**： - **线程优先级**：设置线程的优先级，以影响调度顺序。 - **线程休眠**：调用Thread.sleep()使线程暂停执行指定时间。 - **线程让步**：调用Thread.yield()让当前运行的线程暂停，让其他...
嵌入式Linux应用程序开发第9章多线程编程
07-12
"嵌入式Linux应用程序开发第9章多线程编程" 本章主要讲解了 Linux 中的多线程编程，包括 Linux 线程的基本概念、创建及使用、属性设置、同步与互斥问题的处理等内容。通过学习本章，读者将掌握 Linux 中线程的基本...
线程（九）-- 线程池
weixin_45975659的博客
07-31 130
一、基本介绍 线程池: 已经包含了一些线程, 以便直接使用. 优点：避免了频繁创建 / 销毁线程的开销 线程池本身就是生产者 - 消费者模型。 生产者 - 消费者模型介绍 核心操作: execute: 把一个任务加到线程池中 shutdown: 销毁线程池中的所有线程 线程池的组成:(需要管理两个部分: 将要执行的任务, 正在执行任务的线程) 1. 一个类, 描述具体线程要做的工程(借助 Runnable 表示) 2. 需要一个数据结构来组织若干个任务(BlockingQueue) 3. 先有一个类, 表示
任务，线程和同步（九）之数据流
小猪快跑
02-27 620
数据流Parallel类，Task类和Parallel LINQ为数据并行性提供了很多帮助。但是，这些类不能直接支持数据流的处理，以及并行转化数据。此时，需要使用Task Parallel Library Data Flow（TPL Data Flow）。 这些库必须作为一个NuGet包安装。该包中包含Threading.Tasks.DataFlow名称控件中的Threading.Tasks.Da
一种基于Qt的可伸缩的全异步C/S架构服务器实现(四)数据库的多线程操作
丁劲犇技术发布空间
05-30 5882
四、数据库的多线程操作 在多线程服务中，数据库是
第一行代码Java源代码第10章课程代码Java常用类
10-31
在本课程中，我们主要探讨的是“第一行代码Java”一书中的第10章，这一章主要聚焦于Java常用类库的使用。通过学习这些类库，开发者能够更高效地进行程序开发，掌握Java的强大功能。以下是本章涉及的一些核心知识点：...
java语言版本的`元组`数据类型，实现了元组类型的特性以及常用操作方法，轻量级，无依赖，线程安全
06-10
4. **常用操作方法**： - **构造**：创建元组时，可以通过指定各元素的值来实例化相应的元组类。 - **访问**：通常提供`get`方法来获取元组中的元素，可能按照下标或枚举常量。 - **比较**：可能实现`equals`和`...
Java编程入门第1章测验Java开发Java经验技巧共2
12-01
13. **字符串处理**：String类的常用方法，以及StringBuffer和StringBuilder的区别。 14. **接口与抽象类**：理解接口的定义和实现，以及抽象类的作用。 在“Java开发”部分，可能涵盖了更高级的主题，如： 1. **...
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长
08-12
人力资源+大数据+薪酬报告+涨薪调薪，在学习、工作生活中，越来越多的事务都会使用到报告，通常情况下，报告的内容含量大、篇幅较长。那么什么样的薪酬报告才是有效的呢？以下是小编精心整理的调薪申请报告，欢迎大家分享。相信老板看到这样的报告，一定会考虑涨薪的哦。
SEQ投诉处理与VONR信令及特性介绍
08-12
SEQ平台5G分析模块介绍 投诉分析处理 VoNR信令及特性介绍
毕业设计php企业进销存管理系统-qkrp源码含文档工具包
08-12
毕业设计php企业进销存管理系统-qkrp源码含文档工具包 php，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 类型管理 商品管理 库存查看 库存查看 入库查看 出库查看 用户管理 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程（在说明文档中）
大学生电子设计大赛-《高频电子线路》实验指导书.rar
08-12
大学生电子设计大赛-《高频电子线路》实验指导书.rar
XGBoost深度解析：梯度提升树的极致优化
08-12
机器学习是人工智能的一个分支，它使计算机系统能够从数据中学习并做出决策或预测，而无需进行明确的编程。机器学习算法可以分析大量数据，识别模式和趋势，并根据这些模式做出预测或决策。它包括几种不同的方法，包括： 1. **监督学习**：算法从标记的训练数据中学习，以便对新的输入数据进行分类或预测。 2. **无监督学习**：算法尝试在没有标记的训练数据中找到模式或结构。 3. **半监督学习**：结合了监督学习和无监督学习的方法，使用少量标记数据和大量未标记数据。 4. **强化学习**：算法通过与环境交互来学习，目标是最大化某种累积奖励。 机器学习在许多领域都有应用，包括图像识别、自然语言处理、医疗诊断、股市分析、自动驾驶车辆等。随着技术的发展，机器学习正变得越来越重要，并在不断扩展其应用范围。
ideaTPLINK 课题想法
最新发布
08-12
sasdasdasdasdssss
毕业设计php企业网站-qkrp源码含文档工具包
08-12
毕业设计php企业网站-qkrp源码含文档工具包 php，数据库mysql，jdk1.8，开发工具用ecplise、myecplise、sts、idea都可以 颤|企业介绍|企业新闻|产品中心l服务项目|成功案例|企业招聘|留言本l 包含：源码、数据库脚本、论文、环境工具包、相同框架项目的安装教程（在说明文档中）
ISTQB(高级-测试自动化工程师)考试大纲_模拟题&答案.zip
08-12
ISTQB(高级-测试自动化工程师)考试大纲_模拟题&答案
docker redis离线镜像redis.tar
08-12
docker上的redis离线镜像redis.tar， 用于在docker上离线安装redis
基于Springboot和Vue的汽车资讯网站源码 汽车资讯网站代码（高分优秀毕业设计）
08-12
汽车资讯网站源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！ 系统源码（高分毕设），个人经导师指导并认可通过的98分毕业设计项目，主要针对计算机相关专业的正在做毕设的学生和需要项目实战练习的学习者。也可作为课程设计、期末大作业。包含全部项目源码[代码]、该项目可以直接作为毕设使用。项目技术栈：前端是vue，后端是springboot，项目代码都经过严格调试，代码没有任何bug！
基于Pytorch的图像增强软件
08-12
以打包为exe形式，无需配置环境，下载即用
第1章 认识java语言 第2章 java语言基础 第3章 面向对象程序设计之一 第4章 面向对象程序设计之二 第5章 java基础类库 第6章 图形用户界面程序 第7章 输入输出流 第8章 多线程并发编程 第9章 网络编程 第10章 数据库编程
07-15
### 回答1： 第1章《认识java语言》是介绍Java语言的起源、发展以及特点等基本知识。Java是一种跨平台的高级编程语言，被广泛应用于开发Web和移动应用程序等领域。它具有面向对象、可移植、健壮性好等特点。 第2章《Java语言基础》是介绍Java语言的基本语法、数据类型、运算符、控制流程等内容。学习这些基础知识对于理解和编写Java程序至关重要。 第3章《面向对象程序设计之一》是介绍面向对象编程的原理和基本概念。学习面向对象的思想和方法可以提高程序的可扩展性和重用性。本章内容包括类与对象、封装、继承、多态等知识点。 第4章《面向对象程序设计之二》是进一步探讨面向对象编程的高级特性。学习抽象类、接口、内部类等内容可以让我们写出更加灵活和健壮的Java程序。 第5章《Java基础类库》是介绍Java标准库中的常用类和接口。掌握这些类的使用方法可以大大简化程序开发，如字符串处理、集合框架、IO操作等。 第6章《图形用户界面程序》是介绍使用Java编写图形用户界面（GUI）程序的方法。学习Swing和JavaFX等技术可以实现丰富、直观的用户界面。 第7章《输入输出流》是介绍Java中的输入输出操作。学习文件读写、网络通信等知识可以实现数据的持久化和交互。 第8章《多线程并发编程》是介绍Java多线程编程的原理和方法。学习多线程操作可以充分利用多核处理器的优势，提高程序的并发性和响应性。 第9章《网络编程》是介绍使用Java进行网络通信的方法。学习Socket编程、HTTP协议等内容可以开发出基于网络的应用程序。 第10章《数据库编程》是介绍使用Java连接和操作数据库的方法。学习JDBC等技术可以实现与数据库的交互，进行数据持久化和查询。 通过学习这些章节的内容，可以全面掌握Java语言的基础知识和常用技术，为进一步深入学习和应用Java打下良好的基础。 ### 回答2： 第1章：认识Java语言 第1章介绍了Java语言的基本概念和特点。Java是一种跨平台的编程语言，被广泛应用于Web开发、移动应用开发等领域。Java具有简单易学的特点，使用了面向对象的编程思想，具有良好的可扩展性和可维护性。 第2章：Java语言基础 第2章主要介绍了Java语言的基本语法和常用的数据类型。包括变量、常量、运算符、流程控制语句等。同时还介绍了Java中的数组、字符串和输入输出等相关知识。 第3章：面向对象程序设计之一 第3章介绍了面向对象程序设计的基本概念和常用的面向对象的特性。包括类、对象、继承、封装和多态等。同时还介绍了如何定义和使用类，以及如何实现各种面向对象的特性。 第4章：面向对象程序设计之二 第4章进一步深入介绍了面向对象程序设计的相关知识。包括接口、抽象类、继承和多态的高级应用，以及异常处理和内部类等。这些知识对于构建复杂的面向对象程序非常重要。 第5章：Java基础类库 第5章介绍了Java基础类库中常用的类和方法。包括字符串、日期、时间、集合、文件和输入输出等类库的使用。这些类库为我们提供了丰富的功能，在Java编程中非常实用。 第6章：图形用户界面程序 第6章介绍了Java图形用户界面编程的相关知识。包括Swing和AWT等GUI库的使用，以及事件处理和布局管理器等。通过学习这些知识，我们可以编写出漂亮、交互性强的图形界面程序。 第7章：输入输出流 第7章介绍了Java中输入输出流的使用。包括字节流和字符流的概念、File类的使用以及文件读写和网络通信等。这些知识对于实现数据的读写和传输非常重要。 第8章：多线程并发编程 第8章介绍了Java多线程并发编程的相关知识。包括线程、线程同步和线程通信的概念，以及锁和条件的使用。同时还介绍了线程池的概念和使用，以及如何处理并发编程中的常见问题。 第9章：网络编程 第9章介绍了Java网络编程的基本知识。包括Socket编程、TCP和UDP协议，以及HTTP协议的使用。通过学习这些知识，我们可以编写出具有网络功能的Java应用程序。 第10章：数据库编程 第10章介绍了Java数据库编程的相关知识。包括连接数据库、执行SQL语句、事务处理和数据查询等。通过学习这些知识，我们可以使用Java操作各种类型的数据库。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值