多线程(Thread)
1.认识线程
概念：
- 进程是系统分配资源的最小单位，线程是系统调度的最小单位。一个进程内的线程之间是可以共享资源的。每个进程至少有一个线程存在，即主线程。
2.用代码感受线程
public class ThreadDemo {
/**
* 内部实现静态线程类
*/
private static class MyThread extends Thread{
//1.重写run方法
@Override
public void run() {
System.out.println("第一个线程代码感受!");
}
}
public static void main(String[] args) {
MyThread myThread = new MyThread();
myThread.start();
}
}
import java.util.Random;
public class ThreadDemo {
/**
* 内部实现静态线程类
*/
private static class MyThread extends Thread{
//1.重写run方法
@Override
public void run() {
//System.out.println("第一个线程代码感受!");
Random random = new Random();
while (true) {
// 打印线程名称
System.out.println(Thread.currentThread().getName());
try {
// 随机停止运行 0-9 秒
Thread.sleep(random.nextInt(10));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
public static void main(String[] args) {
MyThread t1 = new MyThread();
MyThread t2 = new MyThread();
MyThread t3 = new MyThread();
t1.start();
t2.start();
t3.start();
Random random = new Random();
while (true){
//currentThread()返回对当前正在执行的线程对象的引用
System.out.println(Thread.currentThread().getName());
try {
Thread.sleep(random.nextInt(10));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
结果：
3.创建一个新的执行线程有两种方法
- 创建一个新的执行线程有两种方法。 一个是将一个类声明为Thread的子类。 这个子类应该重写run类的方法Thread 。 然后可以分配并启动子类的实例。(就是上面的感受代码)。
- 另一种方法来创建一个线程是声明实现类Runnable接口。 那个类然后实现了run方法。 然后可以分配类的实例，在创建Thread时作为参数传递，并启动。(如下)。
start()导致此线程开始执行; Java虚拟机调用此线程的run方法。
public class ThreadDemo {
private static class MyThread2 implements Runnable{
@Override
public void run() {
System.out.println("继承Runable实现线程");
}
}
public static void main(String[] args) {
MyThread2 myThread2 = new MyThread2();
new Thread(myThread2).start();
}
}
4.多线程的优势-增加运行速度
- 接下来通过代码的运行来感受多线程是否增加了运行速度;
- 可以观察多线程在一些场合下是可以提高程序的整体运行效率的;
package 通过代码感受线程;
/**
* 多线程的优势-增加运行速度
*/
public class ThreadDemo2 {
private static final long count = 10_0000_0000;
public static void main(String[] args) throws InterruptedException {
//1.使用并发的方式，也就是多线程的方法
concurrency();
//2.使用串行的方式，也就是我们正常写代码的方式，对比多线程来说就是单线程，全部靠主线程来进行运算
serial();
}
//多线程
private static void concurrency() throws InterruptedException {
long begin = System.currentTimeMillis();//开始运行时间
//1.利用子线程计算a的值
Thread thread = new Thread( new Runnable(){
@Override
public void run() {
long a = 0;
for (long i = 0;i < count;i++){
a++;
}
}
});
thread.start();
//2.主线程计算b的值
long b =0;
for (long i = 0;i < count;i++){
b++;
}
// 等待 thread 线程运行结束
thread.join();
long end = System.currentTimeMillis();//运行结束时间
System.out.println("多线程时间是："+(end-begin));
}
//单线程
private static void serial() {
long begin = System.currentTimeMillis();//开始运行时间
//1.将a和b的计算全部都放在主线程里面
long a = 0;
for (long i = 0;i < count;i++){
a++;
}
long b = 0;
for (long i = 0;i < count;i++){
b++;
}
long end = System.currentTimeMillis();//运行结束时间
System.out.println("单线程时间是："+(end-begin));
}
}
结果：
5. Thread 类及常见方法
6.观察线程的所有状态
public class ThreadDemo {
/**
* 观察线程的所有状态，总共有6中状态
* NEW ：新建
* RUNNABLE ：就绪
* BLOCKED ： 阻塞
* WAITING：等待
* TIMED_WAITING ：带时限的等待(超时等待)
* TERMINATED ： 终止
* @param args
*/
public static void main(String[] args) {
for (Thread.State state : Thread.State.values()){
System.out.println(state);
}
}
}
结果显示：
1.Java中线程的生命周期
