Day18 IO流（打印流、随机访问流）、线程、作业车站售票

最新推荐文章于 2022-05-17 08:30:00 发布
最新推荐文章于 2022-05-17 08:30:00 发布
阅读量175 收藏 1
点赞数
文章标签： java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43986982/article/details/111058740
版权

IO流总结：
在这里插入图片描述

1、打印流

1.1PrintStream和PrintWriter
package Day18_IO3.print;/*
 * @author  pyh
 * @date  2020/12/9 0009 上午 9:58
 * @version 1.0
 * @since JDK1.8_241
 *  打印流
 *          PrintStream：打印字节流
 *          PrintWriter：打印字符流
 */

import org.junit.Test;
import java.io.*;

public class Demo01 {
    //打印字节流
    @Test
    public void test01() throws FileNotFoundException {
        PrintStream ps = new PrintStream(new FileOutputStream("E:\\File\\IO1.txt"));
        //ps.write(98);//b
        //打印流独有的打印方法，直接打印数据，不用转码
        ps.print(98);//98
        ps.close();
    }
    //打印字符流
    @Test
    public void test02() throws IOException {
        PrintWriter pw = new PrintWriter(new FileWriter("E:\\File\\IO1.txt"));
        //pw.write("abc");//abc
        pw.print("abc");//abc
        //pw.print(97);
        pw.close();
    }
}
1.2打印流的输入输出重新定向
package Day18_IO3.print;/*
 * @author  pyh
 * @date  2020/12/9 0009 上午 11:36
 * @version 1.0
 * @since JDK1.8_241
    输入、输出重新定向
 */

import org.junit.Test;
import java.io.*;
import java.util.Scanner;

public class Demo02 {
    //输出
    @Test
    public void test01() throws Exception {
        System.out.println("你还好吗？");
        //改变打印输出的方向
        System.out.println(new PrintStream(new FileOutputStream("IO.txt")));
        //标准的输出方向从控制台改变到IO.txt
        System.out.println("一般般");
    }

    //输入
    public static void main(String[] args) throws Exception {
        System.out.println("请输入你的名字：");
        //System.in是标准输入流，从控制台录入数据
        /*Scanner sc = new Scanner(System.in);
        String name = sc.next();
        System.out.println("你的名字是："+name);*/

        //改变输入流
        System.setIn(new FileInputStream("IO.txt"));//修改标准输入流的方向
        Scanner sc1 = new Scanner(System.in);
        String name = sc1.next();
        System.out.println("你的名字是："+name);
    }
}

练习：

package Day18_IO3.print;
//不通过Scanner类获取控制台的数据
import java.io.*;

public class Demo03 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
        String str = br.readLine();
        System.out.println("控制台录入："+str);
    }
}

2、随机访问流

package Day18_IO3.print.random;/*
        RandomAccessFile：随机访问流
            r:只读    rw：打开以便读取和写入
 */

import org.junit.Test;
import java.io.RandomAccessFile;

public class Demo01 {
    //随机访问流输出流
    @Test
    public void test01() throws Exception {
        RandomAccessFile rw = new RandomAccessFile("E:\\File\\IO1.txt","rw");
        rw.write("xiaohai".getBytes());
        rw.close();
    }
    //指定文件访问
    @Test
    public void test02() throws Exception {
        RandomAccessFile rw = new RandomAccessFile("E:\\File\\IO1.txt","rw");
        /*//设置偏移量，从偏移量开始写入并覆盖。
        rw.seek(1);//源文件内容xiaohai
        rw.write("123".getBytes());//写入x123hai*/

        rw.seek(rw.length());//从末尾开始写入
        rw.write("123".getBytes());
        rw.close();
    }
    //断点续传
    @Test
    public void test03() throws Exception {
        RandomAccessFile r = new RandomAccessFile("D:\\File\\text.mp4","r");
        RandomAccessFile rw = new RandomAccessFile("E:\\File\\text.mp4","rw");
        r.seek(rw.length());
        rw.seek(rw.length());
        //更改byte[1024]可以改变拷贝的速度，越小越慢，越打越快，最大为8192
        byte[] b = new byte[1024];
        int len;
        while ((len = r.read(b)) != -1){
            rw.write(b,0,len);
        }
    }
}

3、线程

3.1进程

进程：程序是静止的，只有真正运行时的程序，才被称为进程。

特点：

  • 单核CPU在任何时间点上。
  • 只能运行一个进程。
  • 宏观并行、微观串行。
3.2线程

线程：又称轻量级进程（Light Weight Process）。

  • 程序中的一个顺序控制流程，同时也是CPU的基本调度单位。
  • 进程由多个线程组成，彼此间完成不同的工作，交替执行，称为多线程。

比如：

  • 迅雷是一个进程，当中的多个下载任务即是多个线程。
  • Java虚拟机是一个进程，默认包含主线程（main），通过代码创建多个独立线程，与main并发执行。
3.3进程和线程区别
  • 进程是操作系统资源分配的基本单位，而线程是CPU的基本调度单位。
  • 一个程序运行后至少有一个进程。
  • 一个进程可以包含多个线程，但是至少需要有一个线程。
  • 进程间不能共享数据段地址，但同进程的线程之间可以。
3.4线程的组成

任何一个线程都具有基本的组成部分：

  • CPU时间片：操作系统（OS）会为每个线程分配执行时间。
  • 运行数据：
    堆空间：存储线程需使用的对象，多个线程可以共享堆中的对象。
    栈空间：存储线程需使用的局部变量，每个线程都拥有独立的栈。
  • 线程的逻辑代码。
3.5线程的创建方式

1、继承Thread类

package Day18_thread01;/*
 * @author  pyh
 * @date  2020/12/9 0009 下午 2:48
 * @version 1.0
 * @since JDK1.8_241
    线程的执行由CPU决定，多线程的表现是CPU快速来回切换不同的线程，达到多条线程同时执行的效果

        线程的创建方式：
            1、自定义线程类继承Thread类，重写run(),实例化线程类，通过对象调用start()启动线程
            2、自定义任务类实现Runnable接口，重写run()，实例化任务类对象，再实例化Thread类对象，在实例化
            Thread对象的时候，通过构造方法传递任务类对象，通过Thread类的对象调用start()启动线程
            3.实现Callable接口，重写call()
            4.通过线程池的方式获取线程并开启
 */

public class Demo01 {
    public static void main(String[] args) {
        MtThread1 thread1 = new MtThread1();
        MtThread2 thread2 = new MtThread2();
        //thread1.run();//调用方法
        thread1.start();//启动线程
        thread2.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程："+i);
        }
    }
}
class MtThread1 extends Thread{
    //重写run()
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程1："+i);
        }
    }
}
class MtThread2 extends Thread{
    public void run(){
        for (int i = 0; i < 60; i++) {
            System.out.println("子线程2："+i);
        }
    }
}

2、实现Runnable接口

package Day18_thread01;/*
 * @author  pyh
 * @date  2020/12/9 0009 下午 3:19
 * @version 1.0
 * @since JDK1.8_241
        自定义任务类实现Runnable接口，重写run()，实例化任务类对象，再实例化Thread类对象，在实例化
            Thread对象的时候，通过构造方法传递任务类对象，通过Thread类的对象调用start()启动线程
 */

public class Demo02 {
    public static void main(String[] args) {
        //实例化任务类对象
        test1 test1 = new test1();
        //再实例化Thread类对象
        Thread thread = new Thread(test1);
        thread.start();//启动线程

        for (int i = 0; i < 100; i++) {
            System.out.println("主线程："+i);
        }
    }
}
class test1 implements Runnable{
    //重写run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程2："+i);
        }
    }
}
3.6线程的睡眠
package Day18_thread01.sleep;/*
 * @author  pyh
 * @date  2020/12/9 0009 下午 4:46
 * @version 1.0
 * @since JDK1.8_241
    睡眠：每打印一句让线程休眠1毫秒
 */

public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread thread = new MyThread();
        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程："+i);
            Thread.sleep(1);
        }
    }
}
class MyThread extends Thread{
    public void run(){
        for (int i = 0; i < 100; i++) {
            System.out.println("子线程..."+i);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

练习：通过控制台不断打印时间

package Day18_thread01.sleep;
import java.text.SimpleDateFormat;
import java.util.Date;
//通过控制台不断打印时间
public class Demo02 {
    public static void main(String[] args) throws InterruptedException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        while (true){
            //睡眠时间 1s = 1000ms
            Thread.sleep(1000);
            String time = sdf.format(new Date());
            System.out.println(time);
        }
    }
}
3.7临界资源

临界资源:多条线程同享一份数据

package Day18_thread01.resource;/*
 * @author  pyh
 * @date  2020/12/9 0009 下午 4:39
 * @version 1.0
 *      临界资源:多条线程同享一份数据
 */

public class Demo01 {
    public static void main(String[] args) {
        //开启线程
        for (int i = 0; i < 10; i++) {
/*            MyThread thread = new MyThread();
            thread.start();*/
            new MyThread().start();
        }
    }
}
class MyThread extends Thread{
    //临界资源
    static int count = 1;

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

线程的生命周期
在这里插入图片描述

4 车站售票

这个作业出现一些问题，例如：几个窗口重复售同一张票；票数为负数才售票结束。

解决这个问题的方法需要用到多线程即明天（Day19）学到的多线程。

package Day18_thread01.resource;/*
 * @author  pyh
 * @date  2020/12/9 0009 下午 7:14
 * @version 1.0
 * @since JDK1.8_241
 *      作业:车站售票,10个窗口出售1000张票
 *              窗口001出售第1000张票
 *              窗口002出售第999张票
 *              窗口007出售第998张票
 *              ...
 *              窗口005出售第1张票
 *              窗口001售票结束
 *              窗口002售票结束
 *              窗口003售票结束
 *              ...
 *              窗口0010售票结束
 */

public class Demo02 {
    public static void main(String[] args) {
        //开10个窗口
        for (int i = 0; i < 10; i++) {
            MyThread1 thread = new MyThread1();
            thread.start();
            //new MyThread1().start();
        }
    }
}
class MyThread1 extends Thread{
    static int count = 1000;
    @Override
    public void run() {
        while (count >= 0){
            if (count == 0){

            }else{
                System.out.println(Thread.currentThread().getName()+"出售第"+count+"张票");
            }
            count--;
        }
        try {
            Thread.sleep(1);
            System.out.println(Thread.currentThread().getName()+"售票结束！！！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
qq_43986982
关注
多线程 IO流
zqb960924的博客
11-27 255
多线程 IO流
Java学习 DAY20 Properties、断言、线程
A969910205的博客
08-28 182
Properties 可以进行持久化的映射类（父类时Hashtable） 键和值都是字符串类型 properties文件都是默认是以GBK来进行编码，但是如果出现中文以u16进行编码 当作配置文件来使用 package cn.tedu.properties; import java.io.FileOutputStream; import java.io.IOException; import java.util.Properties; public class PropertiesDemo1 {
JAVA多线程详解（超详细）
weixin_41121133的博客
11-08 4914
文章目录1. 线程概述1.1 什么是进程1.2 什么是线程1.3 进程和线程的区别1.4 线程的组成1.5 线程的特点2. 线程的创建2.1 创建线程（一）2.2 获取和修改线程名称2.3 一个线程小案例2.4 创建线程（二）2.5 Runnable小案例3. 线程的基本状态4. 线程常用方法5. 线程安全5.1 同步方式（1）5.2 线程基本状态（源码补充）5.3 同步方式（2）5.4 经典问题（死锁）5.5 线程通信5.6 经典问题（生产者消费者）6. 线程池6.1 线程池概念6.2 线程池原理6.3
多线程介绍（归纳）
xasasaa的博客
03-27 621
线程和进程 进程就是计算机中正在进行的一个独立的应用程序，进程是一个动态的概念必须是进行状态，如果一个应用没有启动，那就不是进程 线程就是组成进程的基本单元，可以完成特定的功能，一个进程可以有多个线程组成 进程和线程的区别： 1、内存空间上的区别： 进程是有独有的内存空间，每个进程之间是相互独立的，互不影响 线程有共享的内存空间（也有私有空间） 2、安全性 进程是相互独立的，一个进程的奔溃不会影响到其他的进程，进程是安全 线程存在内存空间共享，一个线程的奔溃可能会影响到其他的线程的执行，线程的安全是不如进程
学习Java第二十八天--多线程之线程的概念、组成和状态
X池鱼
03-11 211
线程的概念、组成、创建方法、状态、同步安全14.多线程14.1 什么是线程14.1.1 什么是进程14.1.2 线程的概念14.1.3 线程的组成14.1.4 创建线程14.2 线程的状态14.2.1 线程的状态(基本)14.2.2 常见方法14.2.3 线程的状态(等待)14.3 线程安全14.3.1 线程安全问题14.3.2 同步方式（1）14.3.3 线程的状态（阻塞） 14.多线程 14....
Java中的IO流之随机访问流，转换流以及打印流
java面试笔试
08-08 220
各位小伙伴今天我们来看看下面的流随机访问流RandomAccessFile 是 object 的子类，此类的实例支持对随机访问文件的读取和写入。在执行 new Rando...
java多线程部分
高精尖发展
04-04 255
java阻塞队列 1、arrayBlockingQueue数组结构、有界阻塞队列 公平非公平 先进先出对元素排序， 默认不保证访问者公平的访问队列 公平访问队列:阻塞all生产者/消费者线程，当队列可用，按阻塞顺序访问队列，先阻塞的生产者线程先往队列插入，先阻塞的消费者线程先从队列获取 公平阻塞队列ArrayBlockingQueue fairQueue = new Ar...
Java笔记 - 黑马程序员_07(多线程，线程同步，线程池，网络编程入门，UDP通信原理，TCP通信原理，commons-io工具类）
逸乐的博客
05-17 879
1. 实现多线程 1.1 进程 进程：是正在运行的程序 是系统进行资源分配郑调用的独立单位 每一个进程都有它自己的内存空间和系统资源 1.2 线程 线程：是进程中的单个顺序控制流，是一条执行路径 单线程：一个进程如果只有一条执行路径，则称为单线程程序 多线程：一个进程如果有多条执行路径，则称为多线程程序 举例： 记事本程序 扫雷程序 1.3 多线程的实现方式(方式1) 方式1：继承Thread类 定义一个类MyThread继承Thread类 在MyThread类中重写run()方法 创建MyT
Linux C语言学习 day5： 进程间的通信方式
haogewudi666的博客
06-17 372
【1】复习 线程：基本概念和特点： 创建线程：pthread_create 线程退出：pthread_exit 线程阻塞：pthread_join gcc xx.c -lpthread 同步：多个线程按照约定的顺序 信号量 初始化：sem_init p操作：申请资源sem_wait v操作: 释放资源sem_post 互斥：多个线程执行时只能有一个线程来访问临界资源 互斥锁 初始化：pthread...
Java一些小实验，简单代码
H.千面的博客
04-26 1357
文章标题一、一些小知识点1、栈和堆2、成员变量和局部变量的区别：3、Object4、字符串遍历5、eclipse快捷生成构造方法6、要学会看 一些方法的源码7、多线程8、二、一些小实验1.Java打印水仙花数，并统计水仙花数的个数2. 系统产生一个 1-100 之间的随机数，请猜出这个数据是多少3. 打印5位数中的回文数4. 不死神兔问题5. 数组反转6. 模拟用户登录7. 字符串大小写转换8、...
java线程5种状态_Java线程的5种状态及切换(透彻讲解)-京东面试
weixin_39946657的博客
02-17 921
一、Thread的几个重要方法：我们先了解一下Thread的几个重要方法。a、start()方法，开始执行该线程；b、stop()方法，强制结束该线程执行；c、join方法，等待该线程结束。d、sleep()方法，线程进入等待。e、run()方法，直接执行线程的run()方法，但是线程调用start()方法时也会运行run()方法，区别就是一个是由线程调度运行run()方法，一个是直接调用了线程中...
21、IO流
AlexAuthor7的博客
01-15 346
IO流 目录 一、File类的使用 二、IO流原理及流的分类 三、节点流 四、缓冲流 五、转换流 六、标准输入、输出流 七、打印流 八、数据流 九、对象流 十、随机存储文件流 十一、NIO.2中Path、 Paths、Files类的使用 一、File类的使用 （一）、File类的使用 1、File类的一个对象，代表一个文件或一个文件目录（俗称文件夹） 2、File类声明在Java.io包下 3、相对路径： 绝对路径： 4、并未涉及到写入湖泊读取问价内容的的操作，如果需要读取或写入文件 内容，必须使用IO流
集合与IO流考试
sun_0128的博客
06-20 887
一.题目要求 一个文本文件test.txt(目录自定),数据内容为部分用户的银行卡消费记录，消费记录信息包含姓名 消费金额，找出消费次数最多的用户，并且该用户单笔消费最高的金额是多少，得出此信息并将信息写入到result.txt中？ 考试要求如下： 1、要求读取文件test.txt(能正确读取15分) 2、要求将文件中的内容按行存入到集合类中(成功存入30分) 3、对集合类中的每一条记录进行分割，分别获取用户名，消费金额(20分) 4、并在上一步基础上进行计数，获取消费次数最多的用户(20分) 5、在上一
python爬虫天猫商品数据及分析（4）
jia666666的博客
08-08 1423
目的 数据导入数据库 数据颜色清洗 机身颜色分析 套餐类型分析 实现 一 商品评价信息导入mysql #!/usr/bin/env python # -*- coding: utf-8 -*- import re import pymysql # 连接database conn = pymysql.connect( host="127.0.0.1", user="root", password="123456", database="test", charse
IO流作业及答案
qq_42591018的博客
04-05 5438
IO流作业 一、填空题 1.IO的含义是 ，data source的含义是 。 2.Java IO流可以分为 和处理流两大类，其中前者处于IO操作的第一线，所有操作必须通过他们进行。 3.输入流的唯一目的是提供通往数据的通道，程序可以通过这个通道读取数据， 方法给程序提供了一个从输入流中读取数据的基本方法。 4.read方法从输入...
Java File类、IO流 实例讲解
读书札记2022的博客
08-23 323
一.IO流概述： 输入流（InputStream）：把数据传到程序中（上传）。 输出流（OutStream）：把数据从程序中输出（下载）。 二.实例化File类的三种方法： import java.io.File; public class TestFile { public static void main(String[] args){ //第一种 File file1 = new File("D:\\a"); //第二种
IOE数据流读写
YongYu_IT的专栏
03-08 496
package File; import java.io.*; public class FileOutDemo { public static void main(String[] args) throws IOException { /* FileOutputStream fo=null; try { fo = new FileOutputStream("guoqing0308.txt"); fo.write("abcdef".
Java线程(一):线程结构图及状态
SayNight
11-01 5913
线程结构图、线程状态及状态转换图
JAVA笔记25-IO流（3）-处理流举例
weixin_30813225的博客
04-24 94
处理流类型： 1、缓冲流 例1： import java.io.*; public class TestBufferStream{ public static void main(String args[]){ try{ FileInputStream fis = new FileInputStream("TestCopyB...
Java IO理解：字节流与字符流解析
2. **IO流的分类**：基于数据流动方向，IO流分为输入流和输出流；依据处理数据的单位，又分为字节流（处理单个字节）和字符流（处理Unicode字符）。字节流的基类是`OutputStream`（输出）和`InputStream`（输入），...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值