多线程

多线程介绍

　　进程： 进程指正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

　　线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序

 

 

程序运行原理

l  分时调度        所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间

l  抢占式调度　　优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个(线程随机性)，Java使用的为抢占式调度。

CPU(中央处理器)使用抢占式调度模式在多个线程间进行着高速的切换。对于CPU的一个核而言，某个时刻，只能执行一个线程，而 CPU的在多个线程间切换速度相对我们的感觉要快，看上去就是在同一时刻运行。

多线程程序并不能提高程序的运行速度，但能够提高程序运行效率，让CPU的使用率更高

 

主线程 jvm启动后，必然有一个执行路径(线程)从main方法开始的，一直执行到main方法结束

多线程内存图

 

创建新执行线程有两种方法。

一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。创建对象，开启线程。run方法相当于其他线程的main方法。

另一种方法是声明一个实现 Runnable 接口的类。该类然后实现 run 方法。然后创建Runnable的子类对象，传入到某个线程的构造方法中，开启线程

创建线程方式一继承Thread类

创建线程的步骤：

1 定义一个类继承Thread。

2 重写run方法。

3 创建子类对象，就是创建线程对象。

4 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法  

注意：线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行

 

Thread.currentThread()获取当前线程对象

getName（） 得到线程名称 

代码：

package com.oracle.demo04;

public class MyThread extends Thread{
	//重写run方法来描述线程任务
	public void run() {
		for (int i = 0; i <100; i++) {
			//getName（） 得到线程名称
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

package com.oracle.demo04;

public class Democracy {
	public static void main(String[] args) {
		//创建线程
		MyThread mt=new MyThread();
		//开启线程
		mt.start();
		//获取相城对象
		//描述主线程任务
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}
}

　　

 创建线程方式—实现Runnable接口

创建线程的步骤。

1、定义类实现Runnable接口。

2、覆盖接口中的run方法。。

3、创建Thread类的对象

4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。

5、调用Thread类的start方法开启线程

package com.oracle.Demo;
//线程任务类
public class Myrunnable implements Runnable{
	//描述线程任务
	@Override
	public void run() {
		for (int i = 0; i <100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
		
	}
}
package com.oracle.Demo;

public class Demo01 {

	public static void main(String[] args) {
		// 创建线程任务对象
		Myrunnable mr=new Myrunnable();
		//创建线程对象
		Thread th=new Thread(mr);
		//开启线程任务
		th.start();
		//描述主线程任务
		for (int i = 0; i < 100; i++) {
			System.out.println(Thread.currentThread().getName()+":"+i);
		}
	}

}

　　

 实现Runnable的好处     

　　避免了单继承的局限性，所以较为常用

　　更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务

　　降低耦合性

 

线程的匿名内部类使用

使用线程的内匿名内部类方式，可以方便的实现每个线程执行不同的线程任务操作。

package com.oracle.Demo;

public class Demo02 {	
	
		/*匿名内部类格式
		 * 父类类型 或接口   对象名=new 父类类型或接口i{
		 * 重写父类方法
		 * }
		 * 
		 * 
		 * */
	public static void main(String[] args) {
		//继承Tread的方式
		Thread th=new Thread(){
			public void run(){
				for (int i = 0; i <100; i++) {
					//getName（） 得到线程名称
					System.out.println(Thread.currentThread().getName()+":"+i);
				}
			}
		};
		//开启线程
		th.start();
		//2.实现Runnable 接口方式
		Runnable r=new Runnable() {
			public void run() {
				for (int i = 0; i <100; i++) {
					//getName（） 得到线程名称
					System.out.println(Thread.currentThread().getName()+":"+i);
				}
			}
		};
		//创建线程对象
		Thread th2=new Thread(r);
		//开启线程
		th2.start();
	}
}