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

并发于并行

并行的速度要快一些

任何一个应用程序都要进入到内存中执行
线程的概念


线程调度

主线程

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();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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
	}
	

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

创建多线程的第一种方式

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);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13

多线程原理　随机性打印结果

多线程原理　多线程内存图解

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);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

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);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13

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

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());
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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());
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

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

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());
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

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();
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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

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();
			}	
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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

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);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

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);
		}

	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Ｔｈｒｅａｄ和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());
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

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);
		}

	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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);
		}

	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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);
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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

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();
		 
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62