Java语言高级-05异常与多线程-第２节线程实现方式

于 2022-09-14 22:55:17 发布
阅读量127 收藏
点赞数
分类专栏： Java学习教程 文章标签： java jvm 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37975179/article/details/126803595
版权

并发于并行
在这里插入图片描述
并行的速度要快一些
在这里插入图片描述
任何一个应用程序都要进入到内存中执行
线程的概念
在这里插入图片描述
在这里插入图片描述
线程调度
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
主线程

package demo22;

/*
主线程：执行主(main)方法的线程

单线程程序：java程序中只有一个线程
执行从main方法开始，从上到下依次执行

java执行main方法，main方法会进入到栈内存
jvm会找操作系统开辟一条main方法通向cpu的执行路径
cpu就可以通过这个路径来执行main方法
而这个路径有一个名字，叫main（主）线程
 */
public class Demo01MainThread {
	public static void main(String[] args) {
		Person p1 = new Person("小强");
		p1.run();
		System.out.println(0/0);//ArithmeticException: / by zero
		
		Person p2 = new Person("旺财");
		p2.run();
	}
}


package demo22;

public class Person {
	private String name;

	public void run() {
		// 定义循环执行20次
		for (int i = 0; i < 20; i++) {
			System.out.println(name+"-->"+i);
		}

	}
	
	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Person(String name) {
		super();
		this.name = name;
	}

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	

}

在这里插入图片描述
创建多线程的第一种方式
在这里插入图片描述

package demo01;

/*
	创建多线程程序的第一种方式：创建Thread类的子类
	java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须是Thread类
	
	实现步骤：
		1、创建一个Thread类的子类
		2、在Thread类的子类种重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
		3、创建Thread类的子类对象
		4、调用Thread类中的方法start方法，开启新的线程，执行run方法
			void start() 使该线程开始执行,java虚拟机调用该线程的run方法
			多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动
		Java程序属于抢占式调度，那个线程的优先级高，那个线程优先执行，同一个优先级，随机选一个执行
			
 */
public class Demo01Thread {

	public static void main(String[] args) {
		//3、创建Thread类的子类对象
		MyThread nt = new MyThread();
		//4、调用Thread类中的方法start方法，开启新的线程，执行run方法
		nt.start();
		
		for (int i = 0; i < 20; i++) {
			System.out.println("main:"+i);
		}
	}
}


package demo01;

//1、创建一个Thread类的子类
public class MyThread extends Thread{
	//2、在Thread类的子类种重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println("run:"+i);
		}
	}
}

多线程原理　随机性打印结果
在这里插入图片描述
多线程原理　多线程内存图解
在这里插入图片描述

package demo01;

/*
	创建多线程程序的第一种方式：创建Thread类的子类
	java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须是Thread类
	
	实现步骤：
		1、创建一个Thread类的子类
		2、在Thread类的子类种重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
		3、创建Thread类的子类对象
		4、调用Thread类中的方法start方法，开启新的线程，执行run方法
			void start() 使该线程开始执行,java虚拟机调用该线程的run方法
			多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动
		Java程序属于抢占式调度，那个线程的优先级高，那个线程优先执行，同一个优先级，随机选一个执行
			
 */
public class Demo01Thread {

	public static void main(String[] args) {
		//3、创建Thread类的子类对象
		MyThread nt = new MyThread();
		//4、调用Thread类中的方法start方法，开启新的线程，执行run方法
		nt.start();
		
		for (int i = 0; i < 20; i++) {
			System.out.println("main:"+i);
		}
	}
}


package demo01;

//1、创建一个Thread类的子类
public class MyThread extends Thread{
	//2、在Thread类的子类种重写Thread类中的run方法，设置线程任务（开启线程要做什么？）
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println("run:"+i);
		}
	}
}

Ｔｈｒｅａｄ类的常用方法　获取线程的名称

package demo02;

/*
线程的名称：
	主线程：main
	新线程：Thread-0,Thread-1,Thread-2
 */
public class Demo01GetThreadName {

	public static void main(String[] args) {
		//创建Thread类的子类对象
		MyThread mt = new MyThread();
		//调用start方法，开启新线程，执行run方法
		mt.start();

		new MyThread().start();
		new MyThread().start();
		
		//链式编程
		System.out.println(Thread.currentThread().getName());
	}
}


package demo02;

/*
获取线程的名称：
	1.使用Thread类中的方法getName()
	 String getName() 返回该线程的名称。
	2.可以先获取到当前正在执行的线程，使用线程中的方法getName()获取线程的名称
	static Thread currentThread() 返回对当前正在执行的线程对象的引用
	 

 */
//定义一个Thread类的子类
public class MyThread extends Thread{

	//重写Thread类中的run方法，设置线程任务
	@Override
	public void run() {
		// 获取线程名称
//		String name = getName();
//		System.out.println(name);
		//Thread t = Thread.currentThread();
//		System.out.println(t);//Thread[Thread-0,5,main]
		
		//String name = t.getName();
		//System.out.println(name);
		
		//链式编程
		System.out.println(Thread.currentThread().getName());
	}
}

Ｔｈｒｅａｄ类的常用方法　设置线程名称

package demo03;

/*
	设置线程的名称：(了解)
		1、使用Thread类中的方法setName（名字）
		void setName(String name)改变线程名称，使之与参数name相同
		2、创建一个带参数的构造方法，参数传递线程的名称，调用父类的带参构造方法，
		把线程名称传递给父类，让父类(Thread)给子线程起一个名字
		Thread(String name)分配给新的Thread对象
		
 */
public class MyThread extends Thread{
	
	public MyThread() {}
	
	public MyThread(String name) {
		super(name);//把线程名称传递给父类，让父类(Thread)给子线程起一个名字
	}
	
	@Override
	public void run() {
		// 获取线程名称
		System.out.println(Thread.currentThread().getName());
	}
}


package demo03;

import demo02.MyThread;

public class Demo01SetThreadName {

	public static void main(String[] args) {
		// 开启多线程
		MyThread mt = new MyThread();
		mt.setName("小强");
		mt.start();

		//开启多线程
		new MyThread("旺财").start();
	}

}

Ｔｈｒｅａｄ类的常用方法　ｓｌｅｅｐ

package demo03;
/*
	public static void sleep(long millis);
	使当前正在执行的线程以执行的毫秒数暂停(暂时停止执行)。
 */
public class Demo01Sleep {

	public static void main(String[] args) {
		//模拟秒表
		for (int i = 0; i <= 60; i++) {
			System.out.println(i);
			
			//使用Thread类的sleep方法让程序睡眠1s
			try {
				Thread.sleep(1000);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}	
		}
	}
}

创建多线程程序的第二种方式　实现

package demo03;

/*
	创建多线程的第二种方式：实现Runnable接口
	java.long.Runnable
		Runnable接口应该由那些打算通过某一线程执行某实例的类来实现。
			类必须定义一个称为run的无参数方法
		Thread(Runnable target)分配新的Thread对象。
		Thread(Runnable target,String name)分配新的Thread对象
	
	实现步骤：
		1、创建一个Runnable接口的实现类
		2、在实现类中重写Runnable接口的run方法，设置线程任务
		3、创建一个Runnable接口的实现类对象
		4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
		5、调用Thread类中的start方法，开启新的线程执行run方法
 */
public class Demo01Runnable {

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


package demo03;

//1、创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{

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

	}
}

Ｔｈｒｅａｄ和Runnable的区别

package demo03;

/*
	设置线程的名称：(了解)
		1、使用Thread类中的方法setName（名字）
		void setName(String name)改变线程名称，使之与参数name相同
		2、创建一个带参数的构造方法，参数传递线程的名称，调用父类的带参构造方法，
		把线程名称传递给父类，让父类(Thread)给子线程起一个名字
		Thread(String name)分配给新的Thread对象
		
	实现Runnable接口创建多线程程序的好处：
		1、创建一个Runnable接口的实现类
		2、在实现类中重写Runnable接口的run方法，设置线程任务
		3、创建一个Runnable接口的实现类对象
		4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
		5、调用Thread类中的start方法，开启新的线程执行run方法
	
	实现Runnable接口创建多线程程序的好处:
		1、避免了单继承的局限性
			一个类只能继承一个类(一个人只能有一个亲爹)，类继承了Thread类就不能继承其他的类
			实现了Runnable接口，还可以继承其他的类，实现其他的接口
		2、增强了程序的扩展性，降低了程序的耦合性(解耦)
			实现Runnable接口的方式，把设置线程程序和开启新线程进行了分离(解耦)
			实现类中，重写了run方法:用来设置线程任务、
			创建Thread类对象，调用start方法：用来开启新线程
 */
public class MyThread extends Thread{
	
	public MyThread() {}
	
	public MyThread(String name) {
		super(name);//把线程名称传递给父类，让父类(Thread)给子线程起一个名字
	}
	
	@Override
	public void run() {
		// 获取线程名称
		System.out.println(Thread.currentThread().getName());
	}
}


package demo03;

//1、创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{

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

	}
}


package demo03;

//1、创建一个Runnable接口的实现类
public class RunnableImpl2 implements Runnable{

	//2、在实现类中重写Runnable接口的run方法，设置线程任务
	@Override
	public void run() {
		for (int i = 0; i < 20; i++) {
			System.out.println("HelloWorld"+i);
		}

	}
}


package demo03;

/*
	创建多线程的第二种方式：实现Runnable接口
	java.long.Runnable
		Runnable接口应该由那些打算通过某一线程执行某实例的类来实现。
			类必须定义一个称为run的无参数方法
		Thread(Runnable target)分配新的Thread对象。
		Thread(Runnable target,String name)分配新的Thread对象
	
	实现步骤：
		1、创建一个Runnable接口的实现类
		2、在实现类中重写Runnable接口的run方法，设置线程任务
		3、创建一个Runnable接口的实现类对象
		4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
		5、调用Thread类中的start方法，开启新的线程执行run方法
 */
public class Demo01Runnable {

	public static void main(String[] args) {
		//3、创建一个Runnable接口的实现类对象
		RunnableImpl run = new RunnableImpl();
		//4、创建Thread类对象，构造方法中传递Runnable接口的实现类对象
		//Thread t = new Thread();//打印线程名称
		Thread t = new Thread(new RunnableImpl2());//打印HelloWorld
		//5、调用Thread类中的start方法，开启新的线程执行run方法
		t.start();
		
		for (int i = 0; i < 20; i++) {
			System.out.println(Thread.currentThread().getName()+"-->"+i);
		}
	}
}

匿名内部类实现线程的创建

package demo03;

/*
	匿名内部类方式实现线程的创建
	
	匿名：没有名字
	内部类：写在其他类内部的类
	
	匿名内部类作用：简化代码
		把子类继承父类，重写父类的方法，创建子类对象合一步完成
		把实现类实现接口，重写接口中的方法，创建实现类对象合成一部完成
	匿名内部类的最终产物:子类/实现类对象，而这个类没有名字
	
	格式：
		new 父类/接口(){
			重复父类/接口中的方法
		};
*/
public class Demo01InnerClassThread {
	public static void main(String[] args) {
		//线程的父类是Thread
		//new MyThread().start();
		new Thread() {
			//重写run方法，设置线程任务
			
			@Override
			public void run() {
				// TODO Auto-generated method stub
				super.run();
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName()+"-->黑马");
				}
			}
		}.start();
		
		//线程的接口Runnable
		//RunnableImpl r = new RunnableImpl();//多态
		Runnable r = new Runnable() {
			//重写run方法，设置线程任务
			@Override
			public void run() {
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName()+"-->程序员");
				}
			}
		};
		new Thread(r).start();
		
		//简化接口的方式
		new Thread(new Runnable() {
			//重写run方法，设置线程任务
			@Override
			public void run() {
				for (int i = 0; i < 20; i++) {
					System.out.println(Thread.currentThread().getName()+"-->传智播客");
				}
			}
		}).start();
		 
	}
}
朗朗乾坤光风霁月
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值