内容
- 什么是线程
- 如何创建线程
- 线程的调度
- 线程的一个设计模式：生产消费者模型
- 线程池
- 线程集合对象（侧重点）
一、什么是线程
进程：运行中的程序才可以称为进程，一个程序一个进程。宏观并行，微观串行。
线程：
1.任何一个程序都至少拥有一个线程，即主线程。但是java程序默认有两个线程，除了主线程之外，还有一个线程，即用于垃圾回收的守护线程。
2.线程是一种轻量级进程，在CPU当中的最基本单元是线程。
3.一个进程可以包含若干的线程
4.各进程之间不共享内存，同进程的各线程之间共享内存
5.每个线程都有独立的栈空间
6.堆当中的地址，可以被共享
注意：
线程是不可控的，只能调度，无法精确控制。研究线程，研究的是如何在多线程场景中，保证数据读写的安全，以及调度线程的运行状态
二、线程的创建和使用
1.通过Thread类来进行创建，需要继承Thread类
package com.mine.demo01;
public class Main1 {
public static void main(String[] args) {
MyThread1 mt1 = new MyThread1();
mt1.start();//调用的不是run方法，而是start
}
}
class MyThread1 extends Thread{
@Override
public void run() {
System.out.println("线程运行了");
}
}
2.通过实现Runnable接口来创建
package com.mine.demo01;
public class Main2 {
public static void main(String[] args) {
Thread t = new Thread(new MyThread2());
t.start();
}
}
class MyThread2 implements Runnable{
@Override
public void run() {
System.out.println("线程被运行了");
}
}
每个线程的逻辑，都是在run方法当中运行的。通过调用start方法来执行线程。start方法只能被调用一次。
3.线程名的创建和获取
Thread t = new Thread(new MyThread2(),"mythreadName2");
t.setName("myNewThreadName2");
t.start();
线程的线程名，需要在启动之前就确定好。
每个线程都有一个默认的名字：Thread-N，N是线程建立的顺序，是一个不重复的正整数
4.获取线程名的方式
在每一个线程的线程栈当中，调用Thread.currentThread().getName()获取线程名
package com.mine.demo01;
public class Main3 {
public static void main(String[] args) {
System.out.println("主线程："+Thread.currentThread().getName());
Thread t = new Thread(new MyThread3());
t.start();
}
}
class MyThread3 implements Runnable {
@Override
public void run() {
System.out.println("子线程：" + Thread.currentThread().getName());
}
}
结果：
主线程：main
子线程：Thread-0
三、线程调度
线程之间传参，共享数据
synchronized：同一时刻，只有一个线程可以调用该方法。
package com.mine.demo01;
public class Main4 {
public static void main(String[] args) {
Test t = new Test();
for (int i = 0 ; i < 1000 ; i ++){
new Thread(new Thread1(t)).start();
}
}
}
//线程数据的共享和传参
class Test{
private int i = 0;
//为了保证数据安全，需要用到同步锁
public synchronized int getI() {
return ++i;
}
}
class Thread1 implements Runnable{
private Test t;
public Thread1(Test t){
this.t = t;
}
@Override
public void run() {
System.out.println(t.getI());
}
}
-
一个正常线程的生命周期
1.新建线程（1生命形态）
2.启动线程
3.就绪状态（2就绪形态）4.等待系统分配资源
5.运行状态（3运行形态）
6.死亡状态（4死亡形态）
1.等待
等待的构成：
1.新建
2.就绪
3.运行
4.持锁（先到就绪状态---->运行）
5.等待
6.释放锁
7.时间到或者被唤醒
8.持锁（先到就绪状态---->运行）
9.执行等待后续
10.死亡
注意：等待必须在同步环境当中，如果不在同步环境中，会报如下异常
java.lang.RuntimeException: java.lang.IllegalMonitorStateException
at com.qf.demo01.Test.getI(Main4.java:18)
at com.qf.demo01.Thread1.run(Main4.java:30)
at java.lang.Thread.run(Thread.java:745)
package com.mine.demo01;
public class Main4 {
public static void main(String[] args) {
Test t = new Test();
for (int i = 0; i < 3; i++) {
new Thread(new Thread1(t)).start();
}
}
}
class Test {
private int i = 0;
public synchronized int getI() {
try {
System.out.println("等待开始前:" + Thread.currentThread().getName());
this.wait(3000);
System.out.println("等待开始后：" + Thread.currentThread().getName());
} catch (Exception e) {
throw new RuntimeException(e);
}
return ++i;
}
}
class Thread1 implements Runnable {
private Test t;
public Thread1(Test t) {
this.t = t;
}
@Override
public void run() {
System.out.println(t.getI());
}
}
运行结果：
等待开始前:Thread-0
等待开始前:Thread-2
等待开始前:Thread-1
等待开始后：Thread-2
1
等待开始后：Thread-1
2
等待开始后：Thread-0
3
注意：只要是线程进入阻塞，那么他一定回先回到就绪状态
2.休眠
package com.mine.demo05;
public class Main {
private synchronized static void test(){
try {
System.out.println("休眠前："+Thread.currentThread().getName());
Thread.sleep(3000);
System.out.println("休眠后："+Thread.currentThread().getName());
}catch (InterruptedException e){
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
for (int i = 0;i < 2 ;i++){
Thread t = new Thread(new Runnable() {
@Override
public void run() {
test();
}
});
t.start();
}
}
}
结果：
休眠前：Thread-0
休眠后：Thread-0
休眠前：Thread-1
休眠后：Thread-1
注意：休眠不释放锁，休眠不可被唤醒，必须等到休眠时间结束
3.优先级（了解）
Thread t = new MyThread();
t.setPriority(5);
t.start();
4.让步（了解）
Thread.yield();//作用仅仅是让当前正在运行的线程回到就绪状态
5.线程的join（生命周期和sleep是一样的）
package com.mine.demo06;
public class Main {
public static void main(String[] args) {
Thread t1 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"......");
try {
Thread.sleep(3000);//3s
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
Thread t2 = new Thread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName()+"++++++");
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
try {
t1.start();
t1.join();
t2.start();
t2.join();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
结果:
Thread-0......
Thread-1++++++
6.守护线程
用户线程：主帅，用户线程只要在运行，守护线程可以一直运行下去，除非守护线程自行死亡
守护线程：卫兵，只要没有用户线程还在继续执行，那么无论其是否还存活，都将立即死亡
四、同步锁
注意：只要是改数据就，就一定要考虑数据同步问题
- 对象锁
//同步方法
public synchronized void getI() {
System.out.println(Thread.currentThread().getName()+"持锁");
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
public void test(){
System.out.println(Thread.currentThread().getName()+" "+i);
synchronized (this){//同步代码块
System.out.println(Thread.currentThread().getName()+"持锁");
try {
Thread.sleep(3000);
i++;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println(i);
}
基于对象的锁，必须是多线程共享的同一个对象
//基于对象的锁
private A a = new A();
public void test(){
// A a = new A();
System.out.println(Thread.currentThread().getName()+" "+i);
synchronized(a){
System.out.println(Thread.currentThread().getName()+"持锁");
try {
Thread.sleep(3000);
i++;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
System.out.println(i);
}
- 类锁
package com.mine.demo02;
public class Main2 {
public static void main(String[] args) {
for(int i = 0 ; i < 3 ; i ++){
new Thread(new Runnable() {
@Override
public void run() {
C.fun1();
}
}).start();
}
}
}
class C{
public synchronized static void fun1(){
try {
System.out.println(Thread.currentThread().getName());
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
public static void fun2(){
synchronized(C.class){
try {
System.out.println(Thread.currentThread().getName());
Thread.sleep(3000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
- 死锁
package com.mine.demo02;
public class Main1 {
public static void main(String[] args) {
Test t = new Test();
new Thread(new Thread1(t)).start();
new Thread(new Thread2(t)).start();
}
}
class Test{
private A a = new A();
private B b = new B();
public void test1(){
synchronized(b){
System.out.println(Thread.currentThread().getName()+"持b锁");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized(a){
System.out.println(Thread.currentThread().getName()+"持a锁");
}
}
}
public void test2(){
synchronized(a){
System.out.println(Thread.currentThread().getName()+"持a锁");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
synchronized(b){
System.out.println(Thread.currentThread().getName()+"持b锁");
}
}
}
}
class Thread1 implements Runnable{
private Test t;
public Thread1(Test t){
this.t = t;
}
@Override
public void run() {
t.test1();
}
}
class Thread2 implements Runnable{
private Test t;
public Thread2(Test t){
this.t = t;
}
@Override
public void run() {
t.test2();
}
}
class A{}
class B{}
注意：
1.静态锁只和静态锁一起用，对象锁只和对象锁一起用，不要混用。
2.持锁顺序保持一致
五、volatile关键字
是一个轻量级的同步锁，因为互斥是同步中最消耗性能的地方，而在读-读/读-写（多读1写），那么这
种情况就只需要考虑可见性。
同步锁的功能包括：互斥，可见
package com.mine.demo02;
public class Person {
private volatile Integer id;
private volatile String name;
public Integer getId() {
return id;
}
public synchronized void setId(Integer id) {
this.id = id;
}
public String getName() {
return name;
}
public synchronized void setName(String name) {
this.name = name;
}
}
六、生产消费者模型
package com.mine.demo03;
import java.util.Date;
//生成者
public class Producer implements Runnable {
private final Queue queue;
public Producer(final Queue queue) {
this.queue = queue;
}
@Override
public void run() {
for(;;){
try {
Thread.sleep(1000);
this.queue.add(Thread.currentThread().getName() + " " + new
Date().getTime());
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
package com.mine.demo03;
import java.util.Date;
//消费者
public class Consumer implements Runnable{
private final Queue queue;
public Consumer(final Queue queue) {
this.queue = queue;
}
@Override
public void run() {
for(;;){
try {
Thread.sleep(1000);
System.out.println(this.queue.get());
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
package com.qf.demo03;
import java.util.LinkedList;
//队列
public class Queue{
private static final int MAX_VALUE = 5;
private LinkedList queue = new LinkedList();
public synchronized void add(Object obj){
while(queue.size()==MAX_VALUE){//用while不要用if
try {
//满了等待
System.out.println(Thread.currentThread().getName() + " 满了，等
待！！");
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
//没有满，添加
this.queue.addFirst(obj);
//每次添加唤醒全部线程
this.notifyAll();
}
public synchronized Object get(){
while (this.queue.size() == 0){
//空了等待
try {
System.out.println(Thread.currentThread().getName() + " 空了，等
待！！");
this.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
//不为空
Object obj = this.queue.getLast();
this.queue.removeLast();
//每次获取唤醒全部线程
this.notifyAll();
return obj;
}
}
package com.mine.demo03;
import com.oracle.jrockit.jfr.Producer;
import java.util.function.Consumer;
public class Main {
public static void main(String[] args) {
Queue queue = new Queue();
new Thread(new Producer(queue)).start();
new Thread(new Producer(queue)).start();
new Thread(new Consumer(queue)).start();
}
}