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

最新推荐文章于 2023-08-02 21:02:49 发布
最新推荐文章于 2023-08-02 21:02:49 发布
阅读量208 收藏
点赞数
文章标签： 设计模式 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
关注
额！Java中用户线程和守护线程区别这么大？
萌兔兔MMQ！！
05-06 397
在 Java 语言中线程分为两类：用户线程和守护线程，而二者之间的区别却鲜有人知，所以本文磊哥带你来看二者之间的区别，以及守护线程需要注意的一些事项。 1.默认用户线程 Java 语言中无论是线程还是线程池，默认都是用户线程，因此用户线程也被成为普通线程。 以线程为例，想要查看线程是否为守护线程只需通过调用 isDaemon() 方法查询即可，如果查询的值为 false 则表示不为守护线程，自然也就属于用户线程了，如下代码所示： public static void main(String[] args)
Java设计模式面试题及参考答案
最新发布
大模型大数据攻城狮的专栏
11-10 838
单例模式是一种设计模式，它确保一个类只有一个实例，并提供一个全局访问点来访问这个实例。单例类的构造函数通常是私有的，这样外部类就无法通过常规方式创建该类的多个实例。通过一个静态方法或者静态变量来获取这个唯一的实例。单例模式的应用场景有很多。比如在数据库连接池中，因为频繁地创建和销毁数据库连接是非常耗费资源的，所以可以使用单例模式来确保整个应用程序只有一个数据库连接池实例，这样多个线程可以共享这个连接池来获取数据库连接。
java多线程总结五：线程池的原理及实现
stefshawn的专栏
11-01 3019
1、线程池简介：     多线程技术主要解决处理器单元内多个线程执行的问题，它可以显著减少处理器单元的闲置时间，增加处理器单元的吞吐能力。         假设一个服务器完成一项任务所需时间为：T1 创建线程时间，T2 在线程中执行任务的时间，T3 销毁线程时间。     如果：T1 + T3 远大于 T2，则可以采用线程池，以提高服务器性能。                 一个线程
实现线程的四种方式
qq_41854180的博客
09-17 452
进程 进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能 线程 线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序 程序 程序是含有指令和数据的文件，被存储在磁盘或其他的数据存储设备中，也就是说程序是静态的代码。 主线程 jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束，这个线程在java中称之为主线程。
java 绿色线程和本地线程区别_在 java 中守护线程和本地线程区别？
weixin_35882722的博客
02-16 422
java 中的线程分为两种：守护线程(Daemon)和用户线程(User)。任何线程都可以设置为守护线程和用户线程，通过方法 Thread.setDaemon(boolon)；true 则把该线程设置为守护线程，反之则为用户线程。Thread.setDaemon()必须在 Thread.start()之前调用，否则运行时会抛出异常。两者的区别：唯一的区别是判断虚拟机(JVM)何时离开，Daemon...
多线程的创建，状态，安全问题(同步代码块)
qq_44807271的博客
10-08 506
Java学习笔记之----------多线程进程线程多线程存在的意义创建多线程 进程 进程：应用程序在内存中分配的空间(正在运行中的程序) 线程 线程： 进程中负责程序执行的执行单元，也称为执行路径 一个进程至少有一个线程负责该进程的执行，称主线程 如果一个进程启用了多个线程，就称该程序为多线程程序 多线程存在的意义 多线程有时并不能提高效率，所以多线程存在的意义不是提高效率，多线程其实是合理使用资源 解决多部分代码同时执行的需求，合理使用CPU资源 多线程的运行是根据CPU的切换完成的，如何切换是由CPU
【3】第三章：C++实现多进程、多线程（附C++代码）
qq_35635374的博客
08-02 833
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对C++实现多进程、多线程做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容C++11提供了语言层面上的多线程，包含在头文件中。它解决了跨平台的问题，提供了管理线程、保护共享数据、线程间同步操作、原子操作等类。C++11 新标准中引入了5个头文件来支持多线程编程，如下图所示。
linux c进程线程的面试问题,linux 多线程面试题_linux进程线程_linux 线程 pthread_create...
weixin_30910583的博客
04-29 1525
你写了一个简单的mandelbrot set程序，也就是说用ps命令行是可以看见多个线程，win32里同一个进程里各个线程之间是共享数据段的，win32的进程管理方式与unix上有着很大区别。adobe flash socket 、 activex htmlfile (ie) 、 基于 multipart 编码发送 xhr 、 基于长轮询的 xhr线程与进程的区别一个程序至少有一个进程,一个进程至...
Java高级：从多线程到java11新特性
qq_43349162的博客
09-10 437
参考：尚硅谷 Java基础 8.多线程 9.Java常用类 10.枚举类和注解 11.Java集合 12.泛型 13.IO流 14.网络编程 15.Java反射机制 16.Java8其他新特性 17.Java9/10/11新特性
深入理解JVM之Java内存模型与线程
muweiyun的博客
03-08 166
对于计算量相同的任务，程序线程并发协调得越有条不紊，效率自然就会越高；反之，线程之间频繁争用数据，互相阻塞甚至死锁，将会大大降低程序的并发能力。
实现线程的几种方式
周梦顺
02-10 516
Java使用Thread类代表线程,所有的线程对象都必须是Thread类或其子类的实例。 Java可以用三种方式来创建线程，如下所示： 1、通过继承Thread类创建线程 /** * (1).首先定义一个类去继承Thread父类，重写父类中的run()方法。在run()方法中加入具体的任务代码或处理逻辑。 * (2).直接创建一个ThreadTest类的对象，也可以利用多态性，变量声...
线程的几种实现方式?
斧头湖懒客
04-09 116
1、通过继承Thread类实现一个线程 2、通过实现Runnable接口实现一个线程 继承thread类的实例是线程的创建者，调用start方法用来开启线程。 实现runnable接口的实例是线程任务的定义者，通过代码我们发现Runnable的实现类并不是线程，它只是作为参数传递到thread类中，thread才是真正的线程，Runnable只是任务，任务和线程是分开的，任务放到线程才会执行，通过Runnable接口实现了设置线程任务和开启线程的分离。 ...
实现线程的方式到底有几种？
Java烂猪皮
09-19 1434
走过路过不要错过点击蓝字关注我们这篇文章主要讲解实现线程的方式到底有几种？以及实现 Runnable 接口究竟比继承 Thread 类实现线程好在哪里？实现线程是并发编程中基础中的基础，...
实现线程的四种方法
bailaoshi666的博客
05-11 1103
1、继承Thread类创建线程 Thread类本质上是实现了Runnable接口的一个实例，代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如： package test; /** * Created by IntelliJ IDEA. .
实现线程（3种方法）
weixin_46143360的博客
10-21 428
实现线程 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
实现线程的三种方式
xf18810669377的博客
06-15 200
3.实现Callable接口（JDK8新特性） 这种方式可以获得线程的返回值，前两种方式无法获取线程返回值，因为run方法返回值为void import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask;//JUC包下，属于Java的并发包，老JDK中没有这个包 public class ThreadTest15 {...
掌握Java多线程编程：从基础到实战深入解析
资源摘要信息:"Java互联网架构多线程并发编程原理及实战 视频教程 下载1.zip" 本资源是一套涵盖Java多线程和并发编程的视频教程，共分为多个章节，每个章节都通过.mp4文件形式提供视频讲解。本视频教程深入浅出地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值