跟我一起学JAVAEE吧——JAVA_SE篇——day15上课笔记（终于弄明白线程和锁机制了）线程线程安全线程状态

65 阅读 0 评论 43 点赞

我是靠谱客的博主魔幻鲜花，最近开发中收集的这篇文章主要介绍跟我一起学JAVAEE吧——JAVA_SE篇——day15上课笔记（终于弄明白线程和锁机制了）线程线程安全线程状态，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

day 15

线程

并发与并行
- 并发：指两个或多个事件在同一个时间段内发生
- 并行：指两个或多个事件在同一时刻发生（同时发生）
线程与进程
- 进程：是指一个内存中运行的应用程序，每个进程都有一个独立的内存空间，一个应用程序可以同时运行多个进程，进程也是程序的一次执行过程，是系统运行程序的基本单位；系统运行一个程序是一个进程从创建，运行到消亡的过程
- 线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序可以称之为多线程
- 简而言之，一个程序运行后至少有一个进程，一个进程中可以包含多个线程
线程调度
- 分时调度：所有线程轮流使用CPU的使用权，平均分配每个线程占用CPU的时间
- 抢占式调度：优先让优先级高的线程使用CPU，如果线程的优先级相同，那么会随机选择一个***（Java使用的是抢占式调度）***

创建线程类

Thread代表线程，所有的线程对象都必须是Thread类或其子类的实例，每个线程的作用是完成一定的任务，实际上就是执行一段程序流即一段顺序执行的代码。

定义Thread类的子类，并重写该类的run()方法，该run()方法的方法体就代表了线程需要完成的任务，因此把run()方法称为线程执行体
创建Thread子类的实例，即创建了线程对象

调用线程对象的start（）方法来启动该线程

public class Demo01{
    public static void main(String[] args){
        MyThread mt = new MyThread("新的线程");//创建自定义线程对象
        mt.start;//开启新线程
        for(int i = 0; i < 10 ;i+){
            System.out.println("main线程"+i);//在主方法中执行for循环
        }
    }
}

public class MyThread extends Thread{
    public MyThread(String name){//定义指定线程名称的构造方法
        super(name);//调用父类的String参数的构造方法，指定线程的名称
    }
    @Override
    public void run(){
        for(int i=0;i<10;i++){
            System.out.pring(getName()+":正在执行！"+i);
        }
    }
}

多线程原理
- 程序启动运行main的时候，Java虚拟机启动一个进程，主线程main在main（）掉哦那个时被创建。随着调用mt的对象的start方法，另外一个新的线程也启动了，这样，整个应用就在多线程下运行
Thread类
- 构造方法
  - public Thread()：分配一个新的线程对象
  - public Thread(String name)：分配一个指定名字的新的线程对象
  - public Thread(Runnable target)：分配一个带有指定目标新的线程对象
  - public Thread(Runnable target,String name)：分配一个带有指定目标新的线程对象并指定名字
- 常用方法
  - public String Getname()：获取当前线程名称
  - public void start()：导致此线程开始执行，Java虚拟机调用此线程的run方法
  - public static void sleep(long millis)：此线程要执行的任务在此处定义代码
  - public static Thread currentThread()：返回当前正在执行的线程对象的引用

创建线程方式二

步骤

定义Runnable接口的实现类，并重写该接口的run（）方法，该run（）方法的方法体同样是该线程的线程执行体
创建Runnable实现类的实例，并以此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象

调用线程对象的start方法来启动线程

public class Myrunnable implements Runnable{
    @Override
    public void run(){
        for(int i=0;i < 20;i++){
            System.out.println(Thread.currentThread().getName()+""+i)
        }
    }
}

public calss Demo{
    public static void main(String [] args){
        Myrunnable mr=new MyRunnable();//创建自定义类对象，线程任务对象
        Thread t= new Thread(mr,"小强");//创建线程对象
        t.start();
        for(int i =0 ;i< 20;i++){
            System.out.ptintln("旺财"+i);
        }
    }
}

Thread和Runnable的区别
- 如果一个类继承Thread，则不适合资源共享。但是如果实现了Runnable接口的话，则很容易实现资源共享
- 实现runnable接口比继承Thread类所具有的优势：
  - 适合多个相同的程序代码的线程去共享同一个资源
  - 可以避免Java中的单继承的局限性
  - 增加程序的健壮性，实现解耦操作，代码可以被多个线程共享，代码和线程独立
  - 线程池只能放入Runnable或Callable类线程，不能直接放入继承Thread的类

匿名内部类方式实现线程的创建

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

使用匿名内部类的方式实现Runnable接口，重新Runnable接口中的run方法：

public class NonameInnerClassThread{
    public static void main(){       
        new Tread(new Runnable(){
            @Override
        	public void run(){
                for(int i=0;i<20;i++){
                    System.out.println("张宇："+i);
                }
            }
        }).start();
        
        for(int i= 0;i<20;i++){
            System.out.println("费玉清"+i);
        }
    }
}

线程安全

概念

如果有多个线程在同时运行，而这些线程可能会同时运行这段代码。程序每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的

模拟卖票

package cn.javase.day15.sellticket;

public class Ticket implements Runnable{
    private int ticket = 100;
    @Override
    public void run() {
        while(true){//每个窗口永远开启卖票操作
            if(ticket>0){//有票可以卖
                try {
                    Thread.sleep(100);//模拟出票时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                String name = Thread.currentThread().getName();
                System.out.println(name+"正在卖，剩余票："+--ticket);//卖出一份，并减少数量
            }
            else {
                break;//小于零则退出程序
            }
        }
    }
}

package cn.javase.day15.sellticket;

public class TicketTest {
    public static void main(String[] args) {
        Ticket ticket=new Ticket();
        Thread t1=new Thread(ticket,"窗口1");
        Thread t2=new Thread(ticket,"窗口2");
        Thread t3=new Thread(ticket,"窗口3");
        t1.start();
        t2.start();
        t3.start();
    }
}
结果：
    。
    。
    。
窗口3正在卖，剩余票：4
窗口2正在卖，剩余票：3
窗口1正在卖，剩余票：3
窗口3正在卖，剩余票：2
窗口2正在卖，剩余票：1
窗口1正在卖，剩余票：1
窗口3正在卖，剩余票：0
窗口1正在卖，剩余票：-1
窗口2正在卖，剩余票：-2

发现程序出现了两个问题：

相同的票数,比如3这张票被卖了两回。

不存在的票，比如0票与-1，-2票，是不存在的。

这种问题，几个窗口(线程)票数不同步了，这种问题称为线程不安全。

线程安全
- 概念
  - 当我们使用多个线程访问同一资源的时候，且多个线程中对资源有写的操作，就容易出现线程安全问题
  - 要解决上述多线程并发访问一个资源的安全性问题：也就是解决重复票与不存在票问题，Java中提供了同步机制synchronized来解决
  - 窗口1线程进入操作的时候，窗口2和窗口3线程只能在外等着，窗口1操作结束，窗口1和窗口2和窗口3才有机会进入代码去执行。也就是说在某个线程修改共享资源的时候，其他线程不能修改该资源，等待修改完毕同步之后，才能去抢夺CPU 资源，完成对应的操作，保证了数据的同步性，解决了线程不安全的现象。

同步代码块

同步代码块：synchronized关键字可以用于方法中的某个区块中，表示只对这个区块的资源实行互斥访问

格式

synchronized(同步锁){
需要同步操作的代码
}

同步锁：对象的同步锁只是一个概念，可以想象为在对象上标记了一个锁

锁对象可以是任意类型
多个线程对象要使用同一把锁
注意：在任何时候，最多允许一个线程拥有同步锁，谁拿到锁就进入代码块，其他的线程只能在外等着

举例

package cn.javase.day15.sellticket;

public class Ticket implements Runnable{
    private int ticket = 100;
    Object lock = new Object();
    @Override
    public void run() {
        while(true){
            synchronized (lock){
                if(ticket>0){
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    String name = Thread.currentThread().getName();
                    System.out.println(name+"正在卖，剩余票："+(--ticket));
                }
                else {
                    break;
                }
            }

        }
    }
}
Test类同上
结果
窗口3正在卖，剩余票：20
窗口3正在卖，剩余票：19
窗口1正在卖，剩余票：18
窗口1正在卖，剩余票：17
窗口1正在卖，剩余票：16
窗口1正在卖，剩余票：15
窗口3正在卖，剩余票：14
窗口2正在卖，剩余票：13
窗口2正在卖，剩余票：12
窗口3正在卖，剩余票：11
窗口1正在卖，剩余票：10
窗口1正在卖，剩余票：9
窗口3正在卖，剩余票：8
窗口3正在卖，剩余票：7
窗口3正在卖，剩余票：6
窗口2正在卖，剩余票：5
窗口2正在卖，剩余票：4
窗口3正在卖，剩余票：3
窗口1正在卖，剩余票：2
窗口3正在卖，剩余票：1
窗口3正在卖，剩余票：0

当使用了同步代码块后，上述线程的安全问题解决了

同步方法

使用synchronized修饰方法，就叫做同步方法，保证A线程执行该方法的时候，其他线程只能在方法外等着

格式：

public synchronized void method(){
    可能产生线程安全问题的代码
}

使用同步方法代码

package cn.javase.day15.sellticket;

public class Ticket implements Runnable{
    private int ticket = 100;
    public synchronized boolean sellticket() {
        if (ticket > 0) {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "正在卖，剩余票：" + (--ticket));
            return true;
        }
        else return false;
    }
    @Override
    public void run() {
        while (true){
            if (sellticket()) {//如果为真继续卖票
            }
            else break;//为假就停止卖票
        }
    }
}
Test类同上
结果
    。
    。
    。
窗口3正在卖，剩余票：21
窗口3正在卖，剩余票：20
窗口3正在卖，剩余票：19
窗口3正在卖，剩余票：18
窗口3正在卖，剩余票：17
窗口3正在卖，剩余票：16
窗口1正在卖，剩余票：15
窗口3正在卖，剩余票：14
窗口2正在卖，剩余票：13
窗口2正在卖，剩余票：12
窗口2正在卖，剩余票：11
窗口2正在卖，剩余票：10
窗口2正在卖，剩余票：9
窗口2正在卖，剩余票：8
窗口2正在卖，剩余票：7
窗口2正在卖，剩余票：6
窗口2正在卖，剩余票：5
窗口2正在卖，剩余票：4
窗口2正在卖，剩余票：3
窗口3正在卖，剩余票：2
窗口3正在卖，剩余票：1
窗口3正在卖，剩余票：0

Lock锁

Java提供了比synchronized代码块和synchronized方法更广泛的锁定操作，同步代码块/同步方法具有的功能Lock都有，除此之外更强大，更体现面向对象

Lock锁也称同步锁，加锁与释放锁方法化

public void lock()：加同步锁

public void unlock()：释放同步锁

package cn.javase.day15.sellticket;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class Ticket implements Runnable{
    private int ticket = 100;
    Lock lock = new ReentrantLock();
    @Override
    public void run() {
        while (true){
            lock.lock();
            if(ticket>0){
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }                System.out.println(Thread.currentThread().getName() + "正在卖，剩余票：" + (--ticket));
            }else
                break;
            lock.unlock();
        }
    }
}
Test类同上
结果
窗口3正在卖，剩余票：15
窗口3正在卖，剩余票：14
窗口1正在卖，剩余票：13
窗口1正在卖，剩余票：12
窗口2正在卖，剩余票：11
窗口2正在卖，剩余票：10
窗口2正在卖，剩余票：9
窗口2正在卖，剩余票：8
窗口2正在卖，剩余票：7
窗口2正在卖，剩余票：6
窗口2正在卖，剩余票：5
窗口3正在卖，剩余票：4
窗口1正在卖，剩余票：3
窗口1正在卖，剩余票：2
窗口1正在卖，剩余票：1
窗口1正在卖，剩余票：0

线程状态

当线程当线程被创建并启动以后，它既不是一启动就进入了执行状态，也不是一直处于执行状态

线程状态	导致状态发生条件
New（新建）	线程刚被创建，但是并未启动。还没调用start方法
Runnable（可允许）	线程可以在Java虚拟机中允许的状态，可能正在运行自己代码，也可能没有，这取决于操作系统处理器
Blocked（锁阻塞）	当一个线程试图获取一个对象锁，而该对象锁其他的线程持有，则该线程进入Blocked状态，当该线程持有锁时，该线程将变成Runnable状态
Waiting（无限等待）	一个线程在等待另一个线程执行一个动作，该线程进入Waiting状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用notify或者notifyAll方法才能唤醒
Timed Waiting（计时等待	同Waiting状态，有几个方法有超时参数，调用他们将进入Timed Waiting状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有Thread.sleep,Object.wait
Teminated(被终止)	因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡

我们不需要去研究这几种状态的实现原理，我们只需知道在做线程操作中存在这样的状态。那我们怎么去理解这几个状态呢，新建与被终止还是很容易理解的，我们就研究一下线程从Runnable（可运行）状态与非运行状态之间的转换问题

Timed Waiting（计时等待）

概念：在我们写卖票的案例中，为了减少线程执行太快，现象不明显等问题，我们在run方法中添加了sleep语句，这样就强制当前正在执行的线程休眠（暂停执行），以减慢线程

实现一个计数器，计数到100，在每个数字之间暂停1秒，每隔10个数字输出一个字符串

package cn.javase.day15;

public class PrintNumber implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%10==0){
                System.out.println("---------");
            }
            System.out.println(i);
            try {
                Thread.sleep(500);
                System.out.println("睡眠0.5秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
         new Thread(new PrintNumber()).start();
    }
}
结果
1
睡眠0.5秒
2
睡眠0.5秒
3
睡眠0.5秒
4
睡眠0.5秒
5
睡眠0.5秒
6
睡眠0.5秒
7
睡眠0.5秒
8
睡眠0.5秒
9
睡眠0.5秒
10
---------
睡眠0.5秒
11
睡眠0.5秒
12
睡眠0.5秒
13
睡眠0.5秒
14
睡眠0.5秒
15

进入 TIMED_WAITING 状态的一种常见情形是调用的 sleep 方法，单独的线程也可以调用，不一定非要有协作关系。

为了让其他线程有机会执行，可以将Thread.sleep()的调用放线程run()之内。这样才能保证该线程执行过程中会睡眠

sleep与锁无关，线程睡眠到期自动苏醒，并返回到Runnable（可运行）状态。

Waiting（无限等待)

一个正在无限期等待另一个线程执行一个特别的（唤醒）动作的线程处于这一状态

package cn.javase.day15;

public class WantingTest {
    public static Object obj=new Object();
    public static void main(String [] args){
        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    synchronized (obj){
                        System.out.println(Thread.currentThread().getName()
                                +"===获取到锁对象，调用wait方法，进入wait状态，释放锁对象");
                        try {
                            obj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+
                                "===从wait状态醒来，获取到锁对象，继续执行了");
                    }
                }
            }
        }).start();

        new Thread(new Runnable() {
            @Override
            public void run() {
                while (true){
                    synchronized (obj){
                        try {
                            System.out.println(Thread.currentThread().getName()+"-----等待10秒钟");
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+
                                "-----获取到锁对象，调用notify方法，释放锁对象");
                        obj.notify();
                    }

                }
            }
        }).start();
    }
}
结果
Thread-0===获取到锁对象，调用wait方法，进入wait状态，释放锁对象
Thread-1-----等待10秒钟
Thread-1-----获取到锁对象，调用notify方法，释放锁对象
Thread-0===从wait状态醒来，获取到锁对象，继续执行了
Thread-1-----等待10秒钟
Thread-1-----获取到锁对象，调用notify方法，释放锁对象
Thread-0===获取到锁对象，调用wait方法，进入wait状态，释放锁对象
Thread-1-----等待10秒钟
Thread-1-----获取到锁对象，调用notify方法，释放锁对象
Thread-1-----等待10秒钟
Thread-1-----获取到锁对象，调用notify方法，释放锁对象
Thread-0===从wait状态醒来，获取到锁对象，继续执行了
Thread-0===获取到锁对象，调用wait方法，进入wait状态，释放锁对象
Thread-1-----等待10秒钟
Thread-1-----获取到锁对象，调用notify方法，释放锁对象
Thread-0===从wait状态醒来，获取到锁对象，继续执行了
Thread-0===获取到锁对象，调用wait方法，进入wait状态，释放锁对象
Thread-1-----等待10秒钟
    。
    。
    。

通过上述案例我们会发现，一个调用了某个对象的 Object.wait 方法的线程会等待另一个线程调用此对象的Object.notify()方法或 Object.notifyAll()方法。

其实waiting状态并不是一个线程的操作，它体现的是多个线程间的通信，可以理解为多个线程之间的协作关系，多个线程会争取锁，同时相互之间又存在协作关系。就好比在公司里你和你的同事们，你们可能存在晋升时的竞争，但更多时候你们更多是一起合作以完成某些任务。