JAVA学习

最新推荐文章于 2024-11-14 19:49:43 发布

宁苓

最新推荐文章于 2024-11-14 19:49:43 发布

阅读量96

点赞数

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/qq_55702063/article/details/118034666

版权

Java 专栏收录该内容

29 篇文章 0 订阅

订阅专栏

Day22
一、学习目标
1.多线程
1.1并发与并行
1.2线程与进程
2.创建线程类
二、知识点
1.多线程
我们在之前，学习的程序在没有跳转语句的前提下都是由上至下依次执行,那现在想要设计一个程序,边打游戏边听歌,怎么设计?
要解决上述问题,咱们得使用多进程或者多线程来解决。
1.1 并发与并行

并发:指两个或多个事件在同—个时间段内发生。
并行:指两个或多个事件在同一时刻发生(同时发生)。

在操作系统中,安装了多个程序,并发指的是在一段时间内宏观上有多个程序同时运行，这在单 CPU系统中,每一时刻只能有一道程序执行,即微观上这些程序是分时的交替运行,只不过是给人的感觉是同时运行那是因大分时交替运行的时间是非常短的。而在多个 CPU系统中,则这些可以并发执行的程序便可以分配到多个处理器上(CPU),实现多任务并行执行，即利用每个处理器来处理一个可以并发执行的程序,这样多个程序便可以同时执行。目前电脑市场上说的多核CPU,便是多核处理器,核越多,并行处理的程序越多，能大大的提高电脑运行的效率。
注意:单核处理器的计算机肯定是不能球行的处理多个任务的，只能是多个任务在单个CPU上并发运行。同理线程也是一样的，从宏观角度上理解线程是并行运行的，但是从微观角度上分析却是串行运行的，即一个线程一个线程的去运行,当系统只有一个CPU时,线程会以某种顺序执行多个线程，我们把这种情况称之为线程调度。
1.2 线程与进程
进程:是指一个内存中运行的应用程序,每个进程都有个独立的内存空间,一个应用程序可以同时运行多个进程;进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序即是一个进程从创建、运行到消亡的过程。
线程:线程是进程中的一个执行单元，负责当前进程中程序的执行,一个进程中至少有—个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。简而言之:—个程序运行后至少有个进程,一个进程中可以包含多个线程。
我们可以再电脑底部任务栏，右键---->打开任务管理器可以查看当前任务的进程:（应用下的和后台进程下的每一行都是一个进程）

线程调度：
分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间。
抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。
设置线程的优先级:（右击设置优先级）
抢占式调度详解
大部分操作系统都支持多进程并发运行，现在的操作几平都支持同时运行多个程序。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时，还开着画图板，dos窗口等软件。此时，这些程序是在同时运行，“感觉这些软件好像在同一时刻运行着”。
实际上，CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。其实，多线程程序并不能提高程序的运行速度，但能够提高程序行运行效率，让CPU的使用率更高。

2.创建线程类
Java使用java.lang.Thread类代表线程，所有的线程对象都必须是Thread类或其子类的实例。每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。Java使用线程执行体来代表这段程序流。Java中通过继承Threade类来创建并启动多线程的步骤如下:
●定义Thread类的子类，并重写该类的run( )方法，该run( )方法的方法体就代表了线程需要完成的任务，因此把run( )方法称为线程执行体。
●创建Thread子类的实例，即创建了线程对象。
●调用线程对象的start( )方法来启动该线程。
构造方法：
●public Thread() :分配一个新的线程对象。
●public Thread(String name) :分配一个指定名字的新的线程对象。
●public Thread(Runnable target) :分配一个带有指定目标新的线程对象。
●public Thead(Runnable target,String name) :分配一个带有指定目标新的线程对象并指定名字。
常用方法:
●public string getName() :获取当前线程名称。
●public void start() :导致此线程开始执行.java建拟机调用此线程的run方法。
●public void run() :此线程要执行的任务在此处定义代码。
●public static void sleep (long millis) :使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行)。
●public static Thread currentThread( ) :返回对当前正在执行的线程对象的引用。
翻阅API后得知创建线程的方式总共有两种，一种是继承read类方式，一种是实现Runnable接口方式，方式二的实现方式：
采用java.lang.Runnable也是非常常见的一种，我们只需要重写run方法即可。
步骤如下:
1.定义Runnable接口的实现类，并重写该接口的run( )方法，该run( )方法的方法体同样是该线程的线程执行体。
2.创建Runnable实现类的实例,并以此实例作为Thread的tareget来创建Thread对象，该Thread对象才是真正的。
三、应用运行
1.多线程
代码示例

package demo01;
/* Z主线程 执行main( )方法的线程
 * 单线程程序: 只有一个线程在执行，从头到尾
 * */
public class Demo01MAainThread {
	public static void main(String[] args) {
		Person p1= new Person("小石");
        p1.run();
        //System.out.println();
        Person p2= new Person("苓苓");
        p2.run();
	}
}

package demo01;

public class Person {
	private String name;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Person (String name) {
		this.name = name;
	}
	public Person () {
		
	}
	public void run() {
		for(int i=0;i<10;i++)
		{
			System.out.println(name+"-->"+i);
		}
	}
}

运行结果
在这里插入图片描述 java.long.Thread实现步骤：
1、创建一个Thread类
2、在Thread子类中重写run方法，设置线程任务（干什么）
3、创建Thread子类的对象
4、调用Thread类中的方法start来启动线程，执行run方法
代码示例

package demo01;
public class Demo01Thread {
	public static void main(String[] args) {
		//创建Thread子类的对象
		MyThread mt=new MyThread();
		//调用start方法
		mt.start();
		for(int i=0;i<10;i++)
		{
			System.out.println("主线程"+i);
		}
	}
}

package demo01;
//1.创建thread子类
public class MyThread extends Thread{
    //2.才重写run方法
	public void run() {
		for(int i=0;i<10;i++)
		{
			System.out.println("子线程"+i);
		}
	}
}

运行结果
在这里插入图片描述
1.1并发与并行
代码示例

package demo02;
public class Demo01Thread {
	public static void main(String[] args) {
		//3.创建Thread子类的对象
		MyThread mt=new MyThread();
		// 4.调用start方法
		mt.start();//子线程0
		new MyThread().start();//子线程1
		new MyThread().start();//子线程2
		new MyThread().start();//子线程3
		System.out.println("main"+Thread.currentThread().getName());
	}
}

package demo02;
public class MyThreadName extends Thread{
	public MyThreadName() {}
	public MyThreadName(String name) {
		super(name);//把线程的名字传递给父亲，让父类Thraed给子线程起一个名字
	}
	@Override
	public void run() {
		/*String name=getName
		 * System.out.println("run"+name);
		 * */
		System.out.println("子:"+Thread.currentThread().getName());
	}
}

运行结果
在这里插入图片描述
代码示例

package demo02;

public class Demo02ThreadSetName {
	public static void main(String[] args) {
		MyThreadName mt=new MyThreadName("千寻");
				mt.start();
				new MyThreadName("龙猫").start();
	}
}

package demo02;
//创建thread子类
public class MyThread extends Thread{
	//重写run方法
	public void run() {
		/*String name=getName
		 * System.out.println("run"+name);
		 * */
		System.out.println("子："+Thread.currentThread().getName());
	}
}

运行结果
在这里插入图片描述
1.2线程与进程
代码示例

package demo03;
public class Demo03Sleep {
	public static void main(String[] args) {
		for(int i=1;i<12;i++) {
			System.out.println(i);
			try {
				Thread.sleep(1000);
			}catch(InterruptedException e){
				e.printStackTrace();
			}
		}
	}
}

运行结果
在这里插入图片描述
2.创建线程类
代码示例
实现runnable接口创建多线程的好处：
1、避免了单继承的局限性
2、增强了程序的扩展性，降低了程序的耦合性

package demo04;
public class Demo04Runnablelmpl {
	public static void main(String[] args) {
		//3.创建一个runnable接口的实现类 对象
		//Runnablelmpl run=new Runnablelmpl();
		//4.创建Thread类对象，构造方法中传递Runnable接口实现类对象
		//Thread t=new Thread(run);
		//5.调用Thread类中的start方法，启动子线程
		Thread t=new Thread(new Runnablelmpl2());
		t.start();
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}

package demo04;
//1、创建一个runnable接口的实现类
public class Runnablelmpl implements Runnable{
//2、在实现类中，重写runnable中的run方法，设置线程任务
	@Override
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	} 
}

package demo04;
public class Runnablelmpl2 implements Runnable {
	public void run() {
		for(int i=0;i<20;i++) {
			System.out.println("Holleworld"+i);
		}
	}
}

运行结果
在这里插入图片描述
以买票为例，将线程和进程一起运用
代码示例

package Demo05;
public class Demo01Ticket {
	public static void main(String[] args) {
		Runnablelmpl run= new Runnablelmpl();
		Thread t0= new Thread(run);
		Thread t1= new Thread(run);
		Thread t2= new Thread(run);
		t0.start();
		t1.start();
		t2.start();
	}
}

解决线程安全问题的一种方案: 使用同步代码块
格式：synchronized(锁对象){
可能会出现线程安全的代码(是因为访问了共享的数据）
}
注意:
1.通过代码块中的锁对象,可以使用任意的对象
2.但是必须保证多个线程使用的锁对象是统一个
3.锁对象作用:把同步代码块锁住,只让一个线程执行

package Demo05;
public class Runnablelmpl implements Runnable{
	public int ticket=100;
	Object obj=new Object();
	@Override
	public void run() {
		while(true) {
			synchronized(obj) {
			if(ticket>0) {
				try {
					Thread.sleep(10);
				}catch(InterruptedException e){
					e.printStackTrace();
				}
				System.out.println(Thread.currentThread().getName()+"-->正在卖第"+ticket+"张票");
				ticket--;
			}
			}
		}
	}
}