多线程（三）线程、线程同步、synchronized锁

多线程（三）线程、线程同步

目录

线程五大状态

哪五大状态

  • 创建状态(NEW)
  • 就绪状态(RUNNABLE)
  • 阻塞状态(BLOCKED)
  • 运行状态
  • 死亡状态

五大状态的关系

  • 创建状态--启动线程--》就绪状态
    • 创建状态：Thread t = new Thread(),线程对象一旦创建就能进入到了新生状态
    • 当调用start()方法，线程立即进入就绪状态，但不意味着立即调度执行
  • 就绪状态--获得CPU资源--》运行状态
    • CPU调度
    • 运行状态：进入运行状态，线程才真正执行线程体的代码块
  • 运行状态--释放CPU资源--》就绪状态
    • CPU调度
  • 运行状态--等待用户输入线程休眠--》阻塞状态
    • 当调用sleep，wait或同步锁定时，线程进入阻塞状态就是代码不往下执行，阻塞事件解除后，重新进入就绪状态，等待菜谱调度执行
  • 阻塞状态--阻塞解除--》就绪状态
  • 运行状态--线程自然执行完毕/外部干涉终止线程--》死亡状态
    • 线程中断或者结束，一旦进入死亡状态，就不能再次启动

线程的方法

方法 说明
setPriority(int newPriority) 更改线程的优先级
static void sleep(long millis) 在指定的毫秒内让当前正在执行的线程休眠
void join() 等待该线程终止
static void yield() 暂停当前正在执行的线程对象，并执行其他线程
void interrupt() 中断线程，别用这个方法
boolean isAlive() 测试线程是否处于活动状态

sleep休眠

  • 每一个对象都有一把锁，sleep不会释放锁
  • sleep可以模拟倒计时，网络延时
  • sleep时间到达之后线程进入就绪状态

线程礼让

  • 让当前正在执行的线程暂停，但不阻塞
  • 将线程从运行状态转为就绪状态
  • 让cpu重新调度，礼让不一定成功，看cpu心情

Join

  • Join合并线程，等待此线程执行完成之后，再执行其他线程，其他线程阻塞
  • 类似于插队

线程状态观测

  • Thread.State类（观测状态）

线程的所有状态

  • NEW
    尚未启动的线程处于此状态。
  • RUNNABLE
    在Java虚拟机中执行的线程处于此状态。
  • BLOCKED
    被阻塞等待监视器锁定的线程处于此状态。
  • WAITING
    正在等待另一个线程执行特定动作的线程处于此状态。
  • TIMED_WAITING
    正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
  • TERMINATED
    已退出的线程处于此状态。

线程优先级

  • Java提供了线程调度器监控就绪状态的所有线程，线程调度器按照优先级决定应该调度哪个线程来执行
  • 优先级用数字表示，范围从1~10
  • 优先级
    • 最小优先级：MIN_PRIORITY=1
    • 最大优先级：MAX_PRIORITY=10
    • NORM_PRIORITY=5//默认优先级为5
  • 改变优先级或获得优先级
    • getPriority()
    • setPriority(int xxx)
  • 设置优先级之后，优先级高的先跑的可能性会变大

守护线程

  • 线程分为用户线程和守护线程
  • 虚拟机必须确保用户线程执行完毕
  • 虚拟机不用等待守护线程执行完毕
  • 默认的进程都是用户进程
  • 当用户进程停止之后守护进程就会停止（因为当所有用户进程停止之后虚拟机就会关闭）

线程同步

  • 并发：同一个对象被多个线程同时操作 （如上百万人抢1000张火车票）（同一张银行卡在手机和柜台同时取钱 ）
  • 处理多个线程问题时，多个线程访问同一个对象，并且某些线程还想修改这个对象，这时需要用到线程同步
  • 线程同步 ：一种等待机制，多个需要同时访问此对象的线程进入这个对象的等待池形成队列，等待前面线程使用完毕，下一个线程再使用
  • 线程为了保证安全：队列+锁

锁机制

  • 锁机制：synchronized
  • 当一个线程获得对象的排它锁，独占资源，其他线程必须等待，使用后释放锁即可
  • 锁机制的问题：
    • 一个线程持有锁会导致其他所有需要此锁的线程挂起
    • 在多线程竞争下，加锁，释放锁会导致比较多的上下文切换和调度延时，引起性能问题
    • 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能问题

同步方法

public synchronized void method(int args){}//同步方法(有synchronized就是同步方法)
  • synchronized 方法可以控制对象的访问，每个对象都有对应的一把锁，每个synchronized方法都必须获得调用该方法的对象的锁才能执行，否则线程会阻塞，方法一旦执行，就独占该锁，直到该方法返回才释放锁，后面被阻塞的对象才能获得该锁

同步块

synchronized(Obj){}
  • Obj：同步监视器
    • Obj可以是任何对象，推荐用共享资源作为同步监视器
    • 执行过程：
      1. 第一个线程访问，锁定同步监视器，执行其中代码
      2. 第二个线程访问，发现同步监视器被锁定，无法访问
      3. 第一个线程访问完毕，解锁同步监视器
      4. 第二个线程访问，发现同步监视器没有锁，然后锁定并访问
  • 锁的对象（Obj）是变化的量，需要增删改的对象

代码实例

代码正常停止

public class sxp01 implements Runnable{
    //1.设置一个标识位
    private boolean flag=true;
    @Override
    public void run() {
        int i=0;
        while (flag){
            System.out.println("输出："+(i++));
        }
    }
    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag=false;
    }

    public static void main(String[] args) {
        sxp01 sxp01 = new sxp01();
        new Thread(sxp01).start();
        for (int i=0;i<100000;i++){
            if(i==90000){
                //调用stop方法
                sxp01.stop();
                System.out.println("线程停止");
            }
        }
    }
}
//输出：
输出：0
输出：1
输出：2
输出：3
输出：4
输出：5
输出：6
输出：7
输出：8
输出：9
输出：10
输出：11
输出：12
输出：13
输出：14
输出：15
输出：16
输出：17
输出：18
输出：19
输出：20
输出：21
输出：22
输出：23
输出：24
输出：25
输出：26
输出：27
输出：28
线程停止

线程休眠

public class Sxp02 {
    public void tenDown()throws InterruptedException{
        int num=10;
        while (true){
            Thread.sleep(1000);
            System.out.println(num--);
            if(num<=0){
                break;
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Sxp02 sxp02 = new Sxp02();
        sxp02.tenDown();
    }
}
//输出：
10
9
8
7
6
5
4
3
2
1

线程礼让

public class Sxp03 {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield,"张三").start();
        new Thread(myYield,"李四").start();
    }
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"线程开始执行");
        Thread.yield();//礼让
        System.out.println(Thread.currentThread().getName()+"线程停止执行");
    }
}
//输出：
李四线程开始执行
张三线程开始执行
李四线程停止执行
张三线程停止执行

Join插队

//测试Join
public class Sxp04 implements Runnable{
    @Override
    public void run() {
        for (int i=0;i<100;i++){
            System.out.println("线程vip来了"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Sxp04 sxp04 = new Sxp04();
        Thread thread = new Thread(sxp04);
        thread.start();
        for (int i=0;i<1000;i++){
            if(i==200){
                thread.join();//插队
            }
            System.out.println("张三"+i);
        }
    }
}

观测线程状态

public class Sxp05 {
    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(300);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
            }
            System.out.println("////////////");
        });
        //观测状态
        Thread.State state = thread.getState();
        System.out.println(state);
        //观察启动
        thread.start();
        state=thread.getState();
        System.out.println(state);
        //只要线程不终止，就一直输出
        while (state!=Thread.State.TERMINATED){
            Thread.sleep(100);
            state=thread.getState();//更新线程状态
            System.out.println(state);
        }
    }
}
//输出：
NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
////////////
TERMINATED

设置优先级

public class Sxp06 {
    public static void main(String[] args) {
        //主线程默认优先级为5
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
        MY1 my1 = new MY1();
        Thread t1=new Thread(my1);
        Thread t2=new Thread(my1);
        Thread t3=new Thread(my1);
        Thread t4=new Thread(my1);
        Thread t5=new Thread(my1);
        Thread t6=new Thread(my1);
        //先设置优先级
        t1.start();
        t2.setPriority(1);
        t2.start();
        t3.setPriority(4);
        t3.start();
        t4.setPriority(Thread.MAX_PRIORITY);//MAX_PRIORITY=10
        t4.start();
        t5.setPriority(6);
        t5.start();
        t6.setPriority(7);
        t6.start();
    }
}
class MY1 implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"-->"+Thread.currentThread().getPriority());
    }
}
//输出：
main-->5
Thread-0-->5
Thread-1-->1
Thread-3-->10
Thread-4-->6
Thread-2-->4
Thread-5-->7

守护进程

//测试守护进程
//上帝守护你
//守护进程无限进行，当所有用户进程停止之后虚拟机就会关闭，守护进程自然就会停止（不过因为虚拟机关闭需要时间所以用户进程结束之后守护进程可能还会再执行一段时间）
public class Sxp07 {
    public static void main(String[] args) {
        God god=new God();
        You you = new You();
        //让上帝变为守护进程
        Thread thread=new Thread(god);
        thread.setDaemon(true);//默认是false表示的是用户进程，正常的线程都是用户线程
        thread.start();//上帝守护进程启动
        new Thread(you).start();//你  用户进程启动
    }
}
//上帝
class God implements Runnable{
    @Override
    public void run() {
        while (true){
            System.out.println("上帝保佑着你");
        }
    }
}
//你
class You implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 36500; i++) {
            System.out.println("你一生都开心的活着");
        }
    }
}

线程不安全例子

不安全的买票
  • 有-1的和拿到同一张票的
//不安全的买票
public class Sxp08 {
    public static void main(String[] args) {
        BuyTicket buyTicket = new BuyTicket();
        new Thread(buyTicket,"张三").start();
        new Thread(buyTicket,"李四").start();
        new Thread(buyTicket,"王五").start();
    }
}
class BuyTicket implements Runnable{
    private  int ticketNums=10;
    boolean flag=true;//外部停止方式
    @Override
    public void run() {
        //买票
        while (flag){
            try {
                buy();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    private void buy() throws InterruptedException {
        //判断是否有效
        if(ticketNums<=0){
            flag=false;
            return;
        }
        //模拟延时
        Thread.sleep(100);
        //买票
        System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
    }
}
//输出：
王五拿到9
李四拿到8
张三拿到10
张三拿到7
王五拿到7
李四拿到6
张三拿到5
李四拿到4
王五拿到5
李四拿到3
王五拿到2
张三拿到3
李四拿到1
张三拿到-1
王五拿到0
安全的买票
  • 将buy()方法变为同步方法
//不安全的买票
public class Sxp08 {
   public static void main(String[] args) {
       BuyTicket buyTicket = new BuyTicket();
       new Thread(buyTicket,"张三").start();
       new Thread(buyTicket,"李四").start();
       new Thread(buyTicket,"王五").start();
   }
}
class BuyTicket implements Runnable{
   private  int ticketNums=10;
   boolean flag=true;//外部停止方式
   @Override
   public void run() {
       //买票
       while (flag){
           try {
               buy();
           }catch (Exception e){
               e.printStackTrace();
           }
       }
   }
   //synchronized同步方法
   private synchronized void buy() throws InterruptedException {
       //判断是否有效
       if(ticketNums<=0){
           flag=false;
           return;
       }
       //模拟延时
       Thread.sleep(100);
       //买票
       System.out.println(Thread.currentThread().getName()+"拿到"+ticketNums--);
   }
}
//输出：
张三拿到10
张三拿到9
王五拿到8
王五拿到7
王五拿到6
王五拿到5
王五拿到4
王五拿到3
王五拿到2
王五拿到1
同步块
public class Sxp09 {
    public static void main(String[] args) {
        List<String> list=new ArrayList<>();
        for (int i = 0; i < 10000; i++) {
            new Thread(()->{
                //通过锁，一个一个排队往里添加，防止出现，添加到统一位置导致最后长度小于10000的情况
                synchronized(list){
                    list.add(Thread.currentThread().getName());
                }
            }).start();
        }
        try {
            Thread.sleep(3000);
        }catch (Exception e){
            e.printStackTrace();
        }
        System.out.println(list.size());//输出长度
    }
}
//输出：
10000
posted @ 2022-02-20 10:57  史小鹏  阅读(48)  评论(0)    收藏  举报