# 线程 Thread
应用程序一进程为单位运行,一个进程可以分为一到多个线程
windows系统下可以通过任务管理器查看进程
Linux 下可以通过`ps-fe`
进程,线程都可以并行执行,CPU
```
---程序1
---程序2
---程序1
```
操作系统中有一个组价叫任务调度器,将cpu的时间分给不同的程序使用,微观上是串行执行(单核),宏观上是并行。(多核CPU才能真正实现并行)
好处:
1)多进程和多线程可以让程序不被堵塞。
2)充分利用多核CPU的优势,提高运行效率。
## 1.Java中的多线程
Thread类
### 创建线程方法1:
```java
Thread t =new Thread(){
public void run(){//运行
//线程需要执行的代码
//不能抛出检查异常,只能自己处理检查异常
}
};
Thread t1=new Thread(){
@Override
public void run() {
for (int i = 0; i < 10000; i++) {
System.out.println(Thread.currentThread()+"###############");
}
}
};
```
启动线称 start();
Ctrl+ O 方法重写
并行(parallel)和并发(concurrent)
## 创建线程的方法2:
把线程和要执行的代码分开
Thread 代表线程
Runnable可运行的 (线程要执行的代码)
```java
Runnable runnable= new Runnable(){
public void run(){
//要执行的代码
};
}
Thread t = new Thread(runnable对象)
t.start();
/* Runnable run=new Runnable() {
@Override
public void run() {
System.out.println("hello");
}
};*/
Runnable run = () -> System.out.println("hello");//使用
Thread t = new Thread(run);
t.start();
```
## 2.线程中的常见方法
Thread.sleep(long n);让当前线程休眠n秒 把CPU让出去,不影响其他线程。
----------
Thread.currentThread();找到当前线程 toString的形式打印
main也是个特殊的线程,叫主线程(main)
> 注意:可以使用jconsle来查看某个Java进程中线程的运行情况
实例方法
start();让线程启动,只能调用一次,如果调用多次会抛出异常 IllegalThreadException
直接调用run和使用start间接的调用run的区别:
直接调用run是在主线程中执行了run,没有启动新线程。
使用start是启动新的线程。
join();等待,让其他线程先进行
用法:等该进程运行结束再获取某个结果
```java
static int r = 0;
public static void main(String[] args) throws InterruptedException {
Thread t1= new Thread(()->{
System.out.println("t1运行开始");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("t1运行结束");
r = 100;
});
t1.start();
/*System.out.println("main开始");
t1.join();
System.out.println("main结束");*/
t1.join();
System.out.println(r);
}
```
jion(long n);表示等待这个线程结束,最多等待n毫秒。
getName(); 得到线程的名称
yield () 谦让 用法:调试时用
不推荐使用的方法:
stop(); 让线程停止
.suspend ()让线程暂停
.resume() 让线程继续
默认情况下,Java进程需要等待所有线程都运行结束,才会结束。
有一种线程叫守护线程(守护的是主线程),只要主线程运行结束,即使守护线程代码还没有,都会跟着主线程结束。
`例子: 垃圾回收器
`
例:
```java
Thread t1= new Thread(()->{
System.out.println("守护线程开始执行...");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("守护线程结束");
});
t1.setDaemon(true); // 设置该线程为守护线程
t1.start();
Thread.sleep(1000);
```
interrupt() 可以打断正在等待的线程(包括sleep, join的等待)例如:
```java
Thread t = new Thread(()->{
try {
Thread.sleep(5000); // 被打断线程会抛出InterruptedException
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("结束 。。。");
});
t.start();
Thread.sleep(1000);
System.out.println("打断t线程。。。");
t.interrupt();
```
.interrupt()可以打断正在等待的进程
## 3.线程的并发(concurrent)
synchronized (同步关键字) (保证代码块内变量可见性和代码块的原子性。属于重量级操作,性能会受到影响)
语法
```java
synchronized(对象) {
要作为原子操作代码
}
```
用synchronized 解决并发问题:
```java
static int i = 0;
static Object obj = new Object();// 房间,能容纳一个人
public static void main(String[] args) throws InterruptedException {
Thread thread = new Thread(() -> {//甲
for (int j = 0; j < 60000; j++) {
synchronized (obj) { // 甲会锁住这个房间
i++;
}
}
});
Thread thread2 = new Thread(() -> {//乙
for (int j = 0; j < 60000; j++) {
synchronized (obj) { // 乙 在门外等待
i--;
}
}
});
thread.start();
thread2.start();
thread.join();
thread2.join();
System.out.println(i);
}
```
每个对象都有自己的一个monitor(监视器),当一个线程调用synchronized(对象),就是相当于进入了这个对象的监视器,要检查有没有owner,此线程成为owner;但如果已经有owner了,这个线程在entryset的区域等待owner的位置空出来。
成为owner也可以理解为获得了对象的锁。
在竞争的时候,是非公平的。
synchronized必须是进入同一个对象的monitor才有上述的结果。
## 4.volatile 易变的 (只保证可见性)
一个线程对变量的修改,其他线程不可见。
用volatile可以修饰成员变量,静态成员变量。他可以防止线程从自己的**高速缓存**中查找变量的值,必须到主存中获取他的值。
**高速缓存**:取值特别频繁才会产生高速缓存。
他保证的是变量在多个线程之间的可见性,不能保证原子性。
```java
public class Testvolatile {
volatile static boolean run =true;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while (run){
}
});
t.start();
Thread.sleep(1000);
run=false;
}
```
## 5.synchronized的另外两种写法
```java
public synchronized void test(){
}
等价于
public void test(){
synchronized(this){
}
}
//锁住普通方法,相当于锁住调用他的对象this
class Test{
public synchronized static void test{
}
}
等价于
public static void test(){
synchronized(Test.class)
}
锁住静态方法,相当于锁住类对象
```
## 6.线程死锁
a线程 获得 A对象的锁
接下来想获得B对象的锁
b线程 获得 B对象的锁
接下来想获得A对象的锁
例:
```java
Object A = new Object();
Object B = new Object();
Thread a = new Thread(()->{
synchronized (A) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (B) {
System.out.println("操作...");
}
}
});
Thread b = new Thread(()->{
synchronized (B) {
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (A) {
System.out.println("操作...");
}
}
});
a.start();
b.start();
```
检测死锁可以使用 jconsole工具
## 7.wait() notify() notifyAll()
都属Object对象的方法,必须先获得此对象的锁,才能调用这几个方法
wait() 等待
notify()唤醒
他们都是线程之间进行协作的手段
obj.wait();让Objiect监视器的线程等待
obj.notify();让Object上正在等待的线程中挑一个唤醒
obj.notifyAll();让Object上正在等待的线程全部唤醒
```java
public static void main(String[] args) {
Object obj=new Object();
new Thread(()->{
synchronized (obj){
System.out.println("xianchen");
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("执行完");
}
}).start();
new Thread(()->{
synchronized (obj){
System.out.println("xianchen2");
try {
obj.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("执行完le");
}
}).start();
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (obj){
obj.notify();
}
System.out.println("over");
}
}
```
wait()方法实际是会释放对象的锁,进入WaitSet等待区,从而让其他线程获取对象的锁。无限制等待,直到nofity为止。
wait(n) 有时限的等待,到n毫秒后结束等待,或是被notify
面试题:sleep(long)睡眠n毫秒,而wait(long)是等待n毫秒
1)sleep是Thread方法,而wait是Object方法。
2)sleep不需要强制和Synchronized配合使用,但wait需要和Synchronized一起用
3)sleep在睡眠的同时,不会释放对象锁的,但wait在等待的时候会释放对象锁。
## 线程的状态
NEW(新建) 线程刚被创建,但是还没有调用start方法
RUNNABLE(可运行) 当调用了start()方法之后
BLOCKEd(阻塞)当线程进入了monitor监视器区,处于entrySet里准备竞争锁的时候,叫阻塞状态。
WAITING(等待)当调用了对象的wait方法,或调用了线程对象的join方法,进入了waitSet,处于等待状态。
TIME_WAITING当调用wait(long n)join(long n)进入了waitSet,处于有限时的等待状态。
当调用sleep(long n)时让当前线程放弃cpu的时间片睡觉一会儿
TERMINATED 当线程代码运行结束
>五种状态
>NEW(新建),RUNNABLE(可运行),RUNNING(正在运行),阻塞(BLOCKED,WAITING,TIME_WAITING),TERMINATED(终止)
##
> 五种状态:
> NEW(新建), RUNNABLE(可运行) , RUNNING(正在运行), 阻塞(BLOCKED,WAITING, TIMED_WAITING )TERMINATED(终止)
## 9. 如何让两个线程以固定的顺序运行
```java
static Object obj = new Object();
static boolean t2runed = false;// t2是否执行过
// 打印 2, 1
public static void main(String[] args) {
Thread t1 = new Thread(() -> {
synchronized (obj) {
while(!t2runed) { // 如果t2没有执行过
try {
obj.wait(); // 线程t1 先等一会
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
System.out.println(1);
});
Thread t2 = new Thread(()->{
System.out.println(2);
synchronized (obj) {
t2runed = true;
obj.notify();
}
});
t1.start();
t2.start();
}