java基础（14）编码格式修改，打印流，转换流，装饰者设计模式，进程与线程，创建线程三种方式及使用场景，start和run的区别，sleep睡眠

最新推荐文章于 2023-03-08 10:25:31 发布
最新推荐文章于 2023-03-08 10:25:31 发布
阅读量202 收藏
点赞数
文章标签： 设计模式 java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Echoxxxxx/article/details/112846466
版权

1.修改编码格式
InputStreamReader
OutputStreamWriter
以GBK 的编码格式进行读取 UTF-8的文件内容 则会出现乱码
想要保证读写过程中 文字不是乱码,则要保证,流和接触到的文件的编码格式一致

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Arrays;
public class Test {
	public static void main(String[] args) throws IOException {
		try {
			InputStreamReader reader = new InputStreamReader(new FileInputStream("zz.txt"),"UTF-8");
			char[] cs = new char[10];
			int num = reader.read(cs);
			System.out.println(Arrays.toString(cs));		
			//设定编码GBK
			OutputStreamWriter writer = new OutputStreamWriter(new FileOutputStream("dd.txt"),"UTF-8");
			writer.write(cs, 0, num);
			writer.flush();
		} catch (FileNotFoundException e) {		
			e.printStackTrace();
		}	
	}
}

在这里插入图片描述
在这里插入图片描述
2.打印流
PrintStream 帮助实现打印输出效果
System.out标准输出 输出到控制台

import java.io.IOException;
import java.io.PrintStream;
import java.io.PrintWriter;
public class Test2 {
	public static void main(String[] args) throws IOException {
		PrintStream ps = System.out;
		ps.println("aaa");		
		System.out.println("bbb");		
		PrintStream ps2 = new PrintStream("c.txt");
		ps2.println("bb");
		ps2.print("333");
		ps2.write(new byte[] {97,98,99,100});
		ps2.flush();		
		//字符打印流
		PrintWriter writer = new PrintWriter("e.txt");
		writer.write(new char[] {'a','b','c','d'});
		writer.println("aaaa");
		writer.print("aaaa");
		writer.flush();		
		//err 也是printStream流类型
		System.err.println("aaa");
	}
}

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
3.转换流
数据类型是InputStream
字节流转成字符流 InputStreamReader
字节流转成字符流 OutputStreamWriter
Scanner的nextLine方法的实现
一次读取一行

4.装饰者设计模式
耦合性低，提高重用性

public class Util {
	public void print99() {
		for (int i = 1; i < 9; i++) {
			for (int j = 1; j <= i; j++) {
				System.out.print(i+"*"+j+"="+i*j+"\t");
			}
			System.out.println();
		}
	}
}
public class UtilsSon extends Util{
	Util util;
	public UtilsSon(Util util) {	
		this.util = util;
	}
	@Override
	public void print99() {		
		System.out.println("九九乘法表");
		util.print99();
		System.out.println("再见");
	}	
}
public class Test {
	public static void main(String[] args) {
		Util util = new Util();
		util.print99();
		UtilsSon son = new UtilsSon(new Util());
		son.print99();
		// 增加了缓冲区
		// bis 依然还是可以进行读取
		// 也是利用了装饰者模式
		 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(""));
	}
}

在这里插入图片描述
5.进程与线程
进程
每一个独立运行着的软件，就叫做一个进程
独立性：不同的进程之间是独立的，相互之间资源不共享
动态性：进程在系统中不是静止不动的，而是在系统中一直活动的
并发性：多个进程可以在单个处理器上同时进行，且互不影响
线程
一个进程可以有多个线程，每个线程去处理一个特定的子任务。一个进程中至少包含一个线程
线程的执行是抢占式的
单核：只能同时干一件事
进程和线程的关系以及区别
一个进程可以包含多个线程，但是至少需要有一个线程，否则这个进程是没有意义的
进程间不能共享资源，但线程之间可以
系统创建进程需要为该进程重新分配系统资源，而创建线程则容易的多，因此使用线程实现多任务并发比多进程的效率高
在这里插入图片描述

6.多线程的实现
创建方式
1 继承Thread类
2 实现Runnable接口
3 实现Callable接口

1.继承Thread类

  1. 自定义类继承Thread
  2. 重写run方法
  3. 创建子线程对象
  4. 用start方法启动线程
    当两个线程互不相干，没有共享资源，自己只需要做自己的事情时，就可以使用继承Thread方法
    main 线程： 主线程，自己创建的叫做 子线程
    自定义子线程是因为有任务, 没有任务则不需要创建线程
    通过构造方法给子线程赋值名字，给子线程赋值名字setName(name);
public class Test2 {
	public static void main(String[] args) {
		MyThread t = new MyThread2("兔子");
		MyThread t2 = new MyThread2("乌龟");		
		t.start();
		t2.start();
	}
}
class MyThread extends Thread{	
	String name;	
	public MyThread(String name) {
		//1 给子线程赋值名字setName(name);
		// 2. 通过构造方法给子线程赋值名字
		super(name);
		this.name = name;
	}
	@Override
	public void run() {
		for (int i = 0; i < 30; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
		}
	}

在这里插入图片描述
例：实现四个窗口，每个窗口卖20张票

public class Test3 {
	public static void main(String[] args) {
		MyThread1 t1 = new MyThread1("窗口一");
		MyThread1 t2 = new MyThread1("窗口二");
		MyThread1 t3 = new MyThread1("窗口三");
		MyThread1 t4 = new MyThread1("窗口四");		
		t1.start();
		t2.start();
		t3.start();
		t4.start();		
	}
}
	class MyThread1 extends Thread{		
		public MyThread1(String name) {
			super(name);
		}
		int ticket=20;
		@Override
			public void run() {
			for (int i = 1; i <= 20; i++) {
			ticket--;					System.out.println(Thread.currentThread().getName()+"卖出了第"+i+"张票");
				}				
			}
	}

在这里插入图片描述
2 实现Runnable接口
更加适用于,拥有共享资源的情况

  1. 自定义一个实现类 实现Runnable接口
  2. 重写run方法
  3. 创建线程对象，任务
  4. 创建Thread对象，并且将实现类对象作为参数传入Thread构造方法中
  5. start启动线程
    创建匿名内部类时
public class Test4 {
	public static void main(String[] args) {
		// 叫做Runnable对象  只是一个资源对象, 不是线程
				Ticket ticket = new Ticket();				
				// 创建线程对象
				Thread t = new Thread(ticket);
				Thread t2 = new Thread(ticket);
				Thread t3 = new Thread(ticket);
				Thread t4 = new Thread(ticket);				
				// 四个线程共享了一个ticke他空间				
				t.start();
				t2.start();
				t3.start();
				t4.start();				
				// 常用格式
				// 如果只想创建一个子线程 的时候 可以采用这种方式  匿名内部类的方式
				new Thread(new Runnable() {
					@Override
					public void run() {
						for (int i = 0; i < 20; i++) {
							System.out.println("i"+i);
						}
					}
				}).start();				
			}
		}
	class Ticket implements Runnable{			
			int tickt= 100;			
			@Override
			public void run() {
				while(tickt>0){
					tickt--;					System.out.println(Thread.currentThread().getName()+"卖了"+(100-tickt)+"张票"+"还有"+tickt+"张");
				}
			}
		}

在这里插入图片描述

3 实现Callable接口

  1. 定义实现类，实现Callable<线程返回值类型>
    2.重写call（）方法

  2. 创建实现类对象, 但是他不是一个任务

  3. 创建FutrueTask<线程返回值类型> 将线程实现类作为参数传入到FutrueTask的构造方法中

  4. 创建线程Thread对象, 并且将FutrueTask对象作为参数传入构造方法
    6.start（） 启动线程
    适用于: 想要得到线程结果的情况

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;
public class Test5 {
	public static void main(String[] args) throws InterruptedException, ExecutionException {
		MyCallable callable = new MyCallable();
		FutureTask<Integer> task = new FutureTask<>(callable);
		Thread thread = new Thread(task);
		thread.start();
		// 线程启动以后, 就会计算结果, 计算 就可以获取返回结果
		// Integer integer = callable.call();// 仅仅是以方法调用的方式来实现的
		// System.out.println(integer);
		// 子线程执行完毕以后给返回的结果
		Integer integer = task.get();
		// 如果主线程执行到这,子线程还没有执行完毕, 主线程则会阻塞,直到等到子线程执行完毕,返回结果
		System.out.println(integer);
	}
}
class MyCallable implements Callable<Integer> {
	@Override
	public Integer call() throws Exception {
		int sum = 0;
		for (int i = 0; i <= 10000; i++) {
			sum += i;
		}
		Thread.sleep(2000);
		return sum;
	}
}

在这里插入图片描述
7.使用场景
继承Thread方法：没有共享资源，各自线程使用自己属性的情况时使用
实现Runnable接口：1. 拥有共享资源
2. 如果操作比较简单 只想创建一个子线程对象的时候, 可以考虑使用线程匿名内部类的形式

new Thread(new Runnable() {						
	@Override
	public void run() {
	    for (int i = 0; i < 20; i++) {
        System.out.println("i"+i);
							}
						}
					}).start();

实现Callable接口：想要得到线程结果的情况

8.start和run的区别
start() 可以申请一个新的栈,可以启动子线程
run() 只是一个简单的方法调用
9.sleep（）方法
写在哪个线程中就让哪个线程睡眠, 睡醒了以后就可以继续抢占cipu 单位毫秒

public class Test6 {
	public static void main(String[] args) {
		A a = new A();
		a.start();		
		System.out.println("aaa");
		System.out.println("aaa");
	}
}
class A extends Thread{
	@Override
	public void run() {
		for(int i  = 0; i<10;i++){
			System.out.println("haha");
			try {
				Thread.sleep(3000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			System.out.println("heheh");
		}		
	}
}

在这里插入图片描述

Echoxxxxx
关注
实现线程（3种方法）
weixin_46143360的博客
10-21 415
实现线程 1.第一种方式： 编写一个类，直接继承java.lang.Thread,重写run方法 package com; import java.io.*; public class Test { public static void main(String[] args) throws IOException { //这里是main方法。这里代码是属于主线程，在主栈中运行。 //新建一个分支线程对象 MyThread myThread = ne
linux c进程线程的面试问题,linux 多线程面试题_linux进程线程_linux 线程 pthread_create...
weixin_30910583的博客
04-29 1497
你写了一个简单的mandelbrot set程序，也就是说用ps命令行是可以看见多个线程，win32里同一个进程里各个线程之间是共享数据段的，win32的进程管理方式与unix上有着很大区别。adobe flash socket 、 activex htmlfile (ie) 、 基于 multipart 编码发送 xhr 、 基于长轮询的 xhr线程与进程的区别一个程序至少有一个进程,一个进程至...
java多线程总结五：线程池的原理及实现
stefshawn的专栏
11-01 2991
1、线程池简介：     多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。         假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。     如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。                 一个线程
实现线程的四种方式
qq_41854180的博客
09-17 440
进程 进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能 线程 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序 程序 程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。 主线程 jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。
java 绿色线程和本地线程区别_在 java 中守护线程和本地线程区别？
weixin_35882722的博客
02-16 409
java 中的线程分为两种：守护线程(Daemon)和用户线程(User)。任何线程都可以设置为守护线程和用户线程，通过方法 Thread.setDaemon(boolon)；true 则把该线程设置为守护线程，反之则为用户线程。Thread.setDaemon()必须在 Thread.start()之前调用，否则运行时会抛出异常。两者的区别：唯一的区别是判断虚拟机(JVM)何时离开，Daemon...
多线程的创建，状态，安全问题(同步代码块)
qq_44807271的博客
10-08 492
Java学习笔记之----------多线程进程线程多线程存在的意义创建多线程 进程 进程：应用程序在内存中分配的空间(正在运行中的程序) 线程 线程： 进程中负责程序执行的执行单元，也称为执行路径 一个进程至少有一个线程负责该进程的执行，称主线程 如果一个进程启用了多个线程，就称该程序为多线程程序 多线程存在的意义 多线程有时并不能提高效率，所以多线程存在的意义不是提高效率，多线程其实是合理使用资源 解决多部分代码同时执行的需求，合理使用CPU资源 多线程的运行是根据CPU的切换完成的，如何切换是由CPU
Java高级：从多线程到java11新特性
qq_43349162的博客
09-10 417
参考：尚硅谷 Java基础 8.多线程 9.Java常用类 10.枚举类和注解 11.Java集合 12.泛型 13.IO流 14.网络编程 15.Java反射机制 16.Java8其他新特性 17.Java9/10/11新特性
Java基础进阶——多线程与JUC（下）
尼尧Nier的博客
06-05 283
最近在准备面试，把知识点复习一遍，整理出的笔记记录下，里面会穿插代码和面试例题。 内容不是原创，是总结和收集，并在理解的基础上进行一些完善，如果侵权了请联系作者，若有错误也请各位指正。因为收集的时候忘记把来源记录下来了，所以就不po出处了，请见谅（这是个坏习惯，一定改）。 Java基础进阶——多线程与JUC（下）多线程与JUCReadWriteLock 读写锁锁降级ReentrantReadWriteLock 可重入读写锁Callable接口FutureList、Map、Set与线程安全List与线程安全
深入理解JVM之Java内存模型与线程
最新发布
muweiyun的博客
03-08 145
对于计算量相同的任务，程序线程并发协调得越有条不紊，效率自然就会越高；反之，线程之间频繁争用数据，互相阻塞甚至死锁，将会大大降低程序的并发能力。
I/O流（包括操作系统与内核，用户空间）,I/O工作原理，Java I/O流的设计及Java IO系统
m0_52410507的博客
10-31 611
文章目录一.操作系统与内核1.1操作系统1.2内核1.3 关系图二、内核空间和用户空间2.1:目的：2.2、内核空间（Kernel-space）：2.3、内核空间（User-space）:2.4、系统调用：三、数据流四、IO工作原理4.1、磁盘IO典型的IO读写磁盘工作原理如下;4.2、COU复制4.3、DMA复制4.4、网络I/O五、Java I/O流设计5.1、流介绍5.2、流体系5.3、流的实现类5.4、java中流的划分5.5、java I/O原理 在介绍IO流之前，先介绍一下一些基础的概念 一.操
实现线程的几种方式
pt_house的博客
03-31 134
实现线程的几种方式 本系列读《实战java高并发程序设计》有感（02）。 前面提到并发，那么怎样要去创建并发程序呢？答案就是使用线程。 线程又是什么呢？来，请看大屏幕：线程就是轻量级的进程，是操作系统调度的最小单位。这里又出来一个进程，它呢就是系统进行资源分配和调度的基本单位，是操作系统结构的基础。就比茶馆可以看成一个进程，隔壁可能开的是饭店，也可以看成一个进程，里面的小二，收银等就可以看成进程里...
线程的几种实现方式?
斧头湖懒客
04-09 101
1、通过继承Thread类实现一个线程 2、通过实现Runnable接口实现一个线程 继承thread类的实例是线程的创建者，调用start方法用来开启线程。 实现runnable接口的实例是线程任务的定义者，通过代码我们发现Runnable的实现类并不是线程，它只是作为参数传递到thread类中，thread才是真正的线程，Runnable只是任务，任务和线程是分开的，任务放到线程才会执行，通过Runnable接口实现了设置线程任务和开启线程的分离。 ...
实现线程的方式到底有几种？
Java烂猪皮
09-19 1422
走过路过不要错过点击蓝字关注我们这篇文章主要讲解实现线程的方式到底有几种？以及实现 Runnable 接口究竟比继承 Thread 类实现线程好在哪里？实现线程是并发编程中基础中的基础，...
实现线程的四种方法
bailaoshi666的博客
05-11 1089
1、继承Thread类创建线程 Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如： package test; /** * Created by IntelliJ IDEA. .
实现线程的三种方式
yd_mmfly的博客
07-24 185
一、继承Thread类创建线程类 1. 定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。因此把run()方法称为执行体。 2. 创建Thread子类的实例，即创建了线程对象。 3. 调用线程对象的start()方法来启动该线程。 package com.thread;publicclassFirstThreadTestextends...
JavaServlet与JSP基础教程：高效动态网页开发
- 高效：Servlet使用多线程模型，每个请求由一个单独的线程处理，而非创建新的进程，这显著降低了处理请求的开销，提高了系统性能。 - 方便：Servlet提供了丰富的API，如HttpServlet，帮助开发者处理HTTP请求，解析...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值