Java 线程

 

目录

1. 进程的概念

2. 线程的概念

3. 多线程

4. 创建线程

4. 线程的状态

4. 线程的优先级

5. 线程的同步（synchronized）

6. 线程的运行状态总览图

---

1. 进程的概念

进程是计算机中的程序关于某数据集合上的一次运行活动 ，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。在当代面向线程设计的计算机结构中，进程是线程的容器。

2. 线程的概念

• 每个进程至少有一个线程，若程序只有一个线程，那就是程序本身。
• 线程线程，有时被称为轻量进程，是操作系统任务调度的基本单位。
• 同一个进程的多个线程共享IO，内存资源。
• 现代计算机支持多个线程的并发执行。
• 线程是有状态的。

注意：很多多线程是模拟出来的，真正的多线程是指有多个 cpu，即多核,如服务器。如果是模拟出来的多线程，即一个 cpu 的情况下，在同一个时间点，cpu 只能执行一个代码，因为切换的很快，所以就有同时执行的错觉。

3. 多线程

（1）特点

由于单线程满足不了日常的正常需求，所以产生了多线程的产生。

多线程就是有多条顺序执行流“同时”执行，并且它们之间互不干扰。日常中我们所使用的一些应用软件，感觉这些程序是“同时”运行的，但实际上，一个处理器同一时刻只能运行一个进程，只是 CPU 在高速轮换执行让我们有这样的错觉。

（2）图解

（3）多线程的优缺点

1）优点：资源利用率更好;程序设计在某些情况下更简单；程序响应更快。

2）缺点：设计更复杂，上下文切换的开销增大。

4. 创建线程

（1）继承Thread 类

1）步骤：

1. 定义一个类继承于Thread类
2. 重写Thread类中的run方法
3. 直接创建对象Thread的子类对象创建线程
4. 调用start方法开启线程并调用任务的run方法执行

2）示范：

public class Test01 {
	public static void main(String[] args) {

		MyThread01 my01 = new MyThread01();
		my01.start();
		System.out.println("hello");
	}
}

class MyThread01 extends Thread{
	@Override
	public void run() {
		System.out.println("world");
		super.run();
	}
}

（2）实现Runnable接口（推荐）

1）优点：将线程的任务从线程的子类中分离出来，进行单独的封装；面向接口编程，避免单继承局限。

2）步骤：

1. 定义类实现Runnable接口。
2. 覆盖接口中的 run方法，将线程任务代码封装到run方法中。
3. 通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。（为什么？因为线程的任务都封装在Runnable接口子类的对象的run方法中，所以要在线程对象创建时就必须明确要运行的任务）
4. 调用线程对象的start方法开启线程。

3）示范：

public class Test01 {
	public static void main(String[] args) {
		
		MyThread02 my02 = new MyThread02();
		Thread thread = new Thread(my02);
		thread.start();
		System.out.println("hello");
	}
}

class MyThread02 implements Runnable{	
	@Override
	public void run() {
		System.out.println("你好");
	}	
}

（3）实现callable接口（了解即可）

1）优点：能声明异常，能有返回值。

2）缺点： 编写复杂麻烦。

3）代码示范：

public class Test03 {
	public static void main(String[] args) throws Exception {

		ExecutorService s = Executors.newFixedThreadPool(4);
		
		Future<String> f1 = s.submit(new MyThreadCound());
		
		Future<String> f2 = s.submit(new MyThreadCound());
		
		System.out.println("down");
		System.out.println(f1.get());
		System.out.println(f2.get());
		
		s.shutdownNow();
	}
}

class MyThreadCound implements Callable<String>{

	@Override
	public String call() throws Exception {
		int i = 0;
		for (; i < 10; i++) {
			System.out.println("hello" + Thread.currentThread().getName());
		}
		return i + "--->" + Thread.currentThread().getName();
	}	
}

4. 线程的状态

图解

（1）新建：即新生状态，创建Thread对象

（2）就绪：使用stard（）方法

（3）运行：调用run方法

（4）阻塞：调用sleep（）方法，阻塞执行后再次回到就绪状态（注意：后期加上 synchronized 的时候，使用 sleep 是不会释放权利的）

（5）死亡：即程序终止，终止的方式有两种：

1. 正常执行完毕，循环 次数已经到达
2. 外部干涉 （上例中的龟兔赛跑，到达时间后，让线程停止）

• 线程中加入标识 -->属性
• 线程体中 使用改标识 -->死循环
• 对外提供改变改标识的方法 setXxx() terminate() a()...
• 外部根据适当的时机调用该方法 

4. 线程的优先级

只代表概率，不代表绝对先后顺序。

MIN_PRIORITY ： 1
NORM_PRIORITY :5 默认优先级
MAX_PRIORITY ：10 

5. 线程的同步（synchronized）

（1）线程安全问题产生的原因

1. 多个线程在操作共享数据。
2. 操作共享数据的线程的线程代码有多条。

（2）解决思路

将多条操作共享数据的线程封装起来，当右线程在执行这些代码的时候，其他线程不可以参与运算。必须要当前线程把这些代码执行完毕，其他线程参与运行。

1）同步块

synchronized +块:同步块
synchronized (引用类型|对象|类.class) {
} 

2）同步方法

修饰符 synchronized 返回类型|void 方法签名{
} 

（3）同步的好处

解决了线程安全性问题。

（4）同步的弊端

相对降低了效率，因为同步外的线程都会判断同步锁。

（5）同步的前提

同步中必须右多个线程并使用同一个锁。

6. 线程的运行状态总览图