Java同步代码块、线程的生命周期、同步方法、Lock锁、死锁、线程中常用的方法

最新推荐文章于 2024-04-17 13:57:59 发布
最新推荐文章于 2024-04-17 13:57:59 发布
阅读量427 收藏 10
点赞数 5
分类专栏： java 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LIJINGPO/article/details/136088462
版权

Java多线程的几种解决方式

线程的常用的方法：

构造器：

public Thread();分配一个新的线程
public Thread(String name);分配一个指定名字的新线程
public Thread(Runnable target);指定创建线程的目标对象呢，实现了Runnable接口中的run方法
public Thread(Runnable target,String name);分配一个带有指定目标新的线程对象并指定名字

常用方法：

start()：1.启动线程 2.调用线程的run()
run()：将线程要执行的操作，声明在此
currentThread()：获取当前执行代码对应的线程
getName()：获取线程名
setName()：设置线程名
sleep(long 毫秒):静态方法，调用时，可以使调用线程睡眠指定时间
yield()：静态方法，一旦执行此方法，就释放cpu的执行权
join()：在线程a中通过线程b调用join()方法，意味着线程a进入阻塞状态，直到线程b执行结束，线程a才结束阻塞状态，继续运行。
isAlive()：判断线程是否存活，返回值是一个boolean的值

过时方法：
stop():强行结束一个线程，不建议使用
suspend():将线程挂起；可能会造成死锁不建议使用
resume():将挂起线程执行；可能会造成死锁不建议使用

线程优先级（java中使用的抢占式，优先级高的优先使用）：
getPriority():获取线程的优先级；默认优先级是5
setPriority():设置线程的优先级；范围【1-10】
Thread类内部声明的优先级：
public final static int MIN_PRIORITY = 1;最低优先级
public final static int NORM_PRIORITY = 5;默认优先级
public final static int MAX_PRIORITY = 10;最高优先级

线程的生命周期：

JDK中用Thread.State类定义了线程的几种状态 要想实现多线程，必须在主线程中创建新的线程对象。Java语言使用Thread类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：

新建： 当一个Thread类或其子类的对象被声明并创建时，新生的线程对象处于新建状态

**就绪：**处于新建状态的线程被start()后，将进入线程队列等待CPU时间片，此时它已具备了运行的条件，只是没分配到CPU资源

**运行：**当就绪的线程被调度并获得CPU资源时,便进入运行状态， run()方法定义了线程的操作和功能

**阻塞：**在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 CPU 并临时中止自己的执行，进入阻塞状态

**死亡：**线程完成了它的全部工作或线程被提前强制性地中 止或出现异常导致结束

JDK5.0之前：
在这里插入图片描述

JDK5.0之后：
在这里插入图片描述

线程安全解决的方法一、二（同步代码块、同步方法）：

同步代码块：

synchronized(同步监视器){
	//需要被同步的代码
}

说明：
需要被同步到的代码，即为操作共享数据的代码。、
共享数据，即多个线程需要操作的数据
需要被同步的代码，在被synchronized包裹以后，就使得一个线程在操作这些代码的过程中，其他线程必须等待。
同步监视，俗称锁，哪个线程获取了锁，哪个线程就能执行需要被同步的代码
同步监视器，可以使用任何一个类的对象充当，但是，多个线程必须使用同一个同步监视器

注意：
	在实现Runnable中，同步监视器可以考虑使用this
	在继承Thread类的方式中，同步监视器要慎用this，可以考虑当前类.class

同步方法：

说明：
	如果操作共享数据的代码完整声明在了一个方法中，那么我们就可以将此方法声明为同步方法
	非静态的同步不方法，默认同步监视器为this，
	静态的同步方法，默认同步监视器是当前类本身

package com.li.java;

/**
 * 例子：创建三个窗口卖票，总票数100张.使用实现Runnable接口的方式
 * 存在线程的安全问题，待解决。
 *
 * 1.问题：买票过程中，出现了重票、错票 -->出现了线程安全问题
 * 2.问题出现的原因：当某个线程操作车票的过程中，尚未操作完成时，其他线程也参与到操作中。
 * 3.如何解决：当一个线程在操作ticket的时候，其他线程不能参与进来，直到线程a操作完ticket时，
 *            其他线程才能进行操作，这种情况即使线程a出现了阻塞状况，也不能被改变。
 * 4.在java中通过同步机制，来解决线程的安全问题。
 *
 */

class Window1 implements Runnable{

    private int ticket = 100;
//    Object obj = new Object();

    @Override
    public void run() {
        while(true) {
            synchronized(this) {//此时的this：唯一的Window1的对象   方式二：synchronized(obj)
                if (ticket > 0) {
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {

    public static void main(String[] args) {
        Window1 w = new Window1();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}


package com.li.java;

/**
 * 使用同步代码块解决继承Thread类的方式的线程安全问题
 *
 * 例子：创建三个窗口卖票，总票数100张.使用继承Thread类的方式
 *
 * 说明：在继承Thread类创建多线程的方式中，慎用this充当同步监听器，考虑使用当前类充当同步监听器
 */

class Window2 extends Thread{
    private static int ticket = 100;
    static Object obj = new Object();
    public void run() {
        while (true) {
            synchronized(obj){//此处不能写this，因为此时有三个对象。可写：Window2.class
                if (ticket > 0) {
                    try{
                        Thread.sleep(100);
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                  System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                    ticket--;
                }
                else{
                    break;
                }
            }
        }
    }
}



public class WindowTest2 {
    public static void main(String[] args) {
        Window2 w1 = new Window2();
        Window2 w2 = new Window2();
        Window2 w3 = new Window2();
        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");
        w1.start();
        w2.start();
        w3.start();
    }
}


package com.li.java;

/**
 * 使用同步方法解决实现Runnable接口的线程安全问题
 *
 *。
 * 关于同步方法的总结：
 * 1.同步方法仍然涉及到同步监视器，只是不需要显式的声明。
 * 2.非静态的同步方法，同步监视器是：this
 *   静态的同步方法，同步监视器是：当前类本身。
 */
class Window3 implements  Runnable{

    private int ticket = 100;
//    Object obj = new Object();

    @Override
    public void run() {
        while(true) {
         show();
        }
    }

    private synchronized void show(){//同步监视器：this
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}

public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

package com.li.java;

/**
 * 使用同步方法处理继承Thread类的方式中的线程安全问题
 */

class Window4 extends Thread{

    private static int ticket = 100;

    public void run() {
        while(true){
        show();
    }
    }
    private static synchronized void show(){//同步监视器：Window4.class
//    private synchronized void show(){//同步监视器：t1,t2,t3.此解决方法是错误的。
        if (ticket > 0) {

            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
            ticket--;
        }
    }
}



public class WindowTest4 {
    public static void main(String[] args) {
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();
        Window4 w3 = new Window4();

        w1.setName("窗口1");
        w2.setName("窗口2");
        w3.setName("窗口3");

        w1.start();
        w2.start();
        w3.start();
    }
}

死锁：

1.如何看待死锁？
不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

2.诱发死锁的原因？
互斥条件
占用且等待
不可抢夺（或不可抢占）
循环等待
以上4个条件，同时出现时就会触发死锁

3.如何避免死锁？
针对条件1：互斥条件基本无法被破坏，因为线程需要通过互斥解决安全问题
针对条件2：可以考虑一次性申请所有所需的资源，这样就不存在等待问题。
针对条件3：占用部分资源的线程在进一步申请其他资源时，如果申请不到，就主动释放已经占用的资源
针对条件4：可以将资源改为线性顺序，申请资源时，先申请序号小的，避免循环等待

解决线程安全问题的方法三（Lock锁）：

实现Runnable接口的方式：

package com.li.java1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三：Lock锁---->JDK5.0新增
 *
 * 1.面试题：synchronized 与 Lock的异同？
 *  同：二者都可解决线程安全问题
 *  不同：synchronized机制在执行完相应的同步代码块以后，自动的释放同步监视器
 *         Lock需要手动的启动同步（Lock()）,同时结束同步也需要手动实现（unlock()）
 *
 */

class Window implements Runnable{
    private int ticket = 100;

    //1.实例化
    private ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try{

                //2.调用锁定方法lock()
                lock.lock();

                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}

public class LockTest {
    public static void main(String[] args) {
        Window w = new Window();

        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        Thread t3 = new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

继承Thread的方式：

package com.li.java1;

import java.util.concurrent.locks.ReentrantLock;

/**
 * 解决线程安全问题的方式三：Lock锁---->JDK5.0新增
 *
 * 1.面试题：synchronized 与 Lock的异同？
 *  同：二者都可解决线程安全问题
 *  不同：synchronized机制在执行完相应的同步代码块以后，自动的释放同步监视器
 *         Lock需要手动的启动同步（Lock()）,同时结束同步也需要手动实现（unlock()）
 *
 */

class Window extends Thread{
    private static int ticket = 100;

    //1.实例化,必须使用static修饰，保证唯一
    private static final ReentrantLock lock = new ReentrantLock();

    @Override
    public void run() {
        while (true){
            try{

                //2.调用锁定方法lock()
                lock.lock();

                if (ticket > 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":售票，票号为：" + ticket);
                    ticket--;
                }else{
                    break;
                }
            }finally {
                //3.调用解锁方法：unlock()
                lock.unlock();
            }
        }
    }
}

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

        Window t1 = new Window(w);
        Window t2 = new Window(w);
        Window t3 = new Window(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}


package com.li.java2;

/**
 * 线程通信的例子：使用两个线程打印1—100.线程1，线程2交替打印
 *
 * 涉及到的三个方法：
 * wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
 * notify():一旦执行此方法，就唤醒被wait的一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
 * notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
 *
 * 说明：
 * 1.wait()、notify()、notifyAll()三个方法必须使用在同步代码块或同步方法中。
 * 2.wait()、notify()、notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器
 *      否则，会出现IllegalMonitorStateException异常
 * 3.wait()、notify()、notifyAll()三个方法是定义在java.long.Object类中。
 *
 * 面试题：sleep()和wait()的异同？
 * 1.相同点：一旦执行方法，都可以使得当前的线程进入阻塞状态。
 * 2.不同点：1）两个方法声明的位置不同：Thread类中声明sleep(),Object类中声明wait()
 *          2）调用的要求不同：sleep()可以在任何需要的场景下调用。wait()必须使用在同步代码块或同步方法中
 *          3）关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，sleep()不会释放锁，wait()会释放锁。
 *
 */

class Number implements Runnable{
    private int number = 1;
    @Override
    public void run() {

        while (true){
            synchronized (this) {

                notify();

                if (number <= 100){

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":" + number);
                    number++;

                    try {
                        //使得调用如下wait()方法的线程进入阻塞状态
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }else{
                    break;
                }
            }
        }
    }
}
public class CommunicationTest {
    public static void main(String[] args) {
        Number number = new Number();
        Thread t1 = new Thread(number);
        Thread t2 = new Thread(number);

        t1.setName("线程1");
        t2.setName("线程2");

        t1.start();
        t2.start();

    }
}
com.li
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA中线程同步的方法（7种）汇总
weixin_33835690的博客
05-05 846
同步的方法： 一、同步方法 　　即有synchronized关键字修饰的方法。 由于java的每个对象都有一个内置锁，当用此关键字修饰方法时， 内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。 注： synchronized关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类。   二、同步代码块 　　即有synchronized关键字修饰的语句块...
Java 编程下的同步代码块
weixin_34167043的博客
02-13 69
为了便于理解先来看看没有加同步代码块的 2 组同样功能的代码在不同状态下的执行结果，下面看第一组： package cn.sunzn.synchronize; public class SynchronizeCode { public static void main(String[] args) { new Thread() { pub...
Java 多线程 —— 同步代码块（解决线程安全问题)(1)，2024年最新HR的话扎心了
最新发布
04-17 578
同步方法是属于对象，而在这个类里面调用方法的是this对象，也就是this.sellTicket()，因此把this提取出来作为对象锁中的对象。这样多个线程都用的是this锁。System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");System.out.println(Thread.currentThread().getName()+" 正在出售第 “+(tickets–)+” 张票");
Java学习之同步代码块
Ande1922的博客
06-05 365
多线程的安全问题：    当多个线程访问共享数据时，可能会出现线程安全问题。产生问题的原因：    1.线程任务中有处理到共享的数据；    2.线程任务中有多条对共享数据的操作。    一个线程在操作共享数据的过程中，其他线程参与了运算，造成了数据的错误。如何解决多线程的安全问题：    只要保证多条操作共享数据的代码在某一时间段，被一条线程所执行，在期间不允许其他线程参与运算。如何保证？   ...
Java同步代码块
cg_Amaz1ng的博客
06-05 1185
什么是同步代码块： 同步代码块是共用同一把锁的代码块，使用同步代码块可以实现两块代码在执行过程中互斥。 即执行代码块A的时候不执行代码块B，执行代码块B的时候不执行代码块A。 实现方法： 使用静态对象锁。 private static final Object SYNCHRONIZED_OBJECT = new Object(); 举个栗子： public class L...
java 代码块同步,Java 同步代码块
weixin_28702613的博客
03-14 475
Java 同步代码块1 什么是Java同步代码块同步代码块可用于对方法的任何特定资源执行同步。假设您的方法中有50行代码，但是您只想同步5行，则可以使用synchronized代码块。如果将方法的所有代码放在同步代码块中，它的效果与同步方法相同。2 Java同步代码块的要点同步代码块用于锁定任何共享资源的对象。同步代码块的范围小于该方法。3Java同步代码块的语法synchronized (ob...
Java线程唤醒与阻塞常用方法共2页.pdf.zip
10-28
本文将深入探讨Java中用于线程唤醒与阻塞的常用方法，以及它们在实际编程中的应用。 1. **线程的阻塞** - `wait()`: 这个方法属于`Object`类，当一个线程调用对象的`wait()`方法时，它会释放该对象的锁并进入等待...
Java线程实验代码.rar-综合文档
05-20
了解这些状态有助于理解线程执行的生命周期。 5. **线程同步**： Java提供了多种同步机制，包括`synchronized`关键字、`wait()`, `notify()`, `notifyAll()`方法、`Lock`接口（如ReentrantLock）以及`java.util....
Java多线程的用法详细介绍
08-29
本文将详细讲解Java中实现多线程的两种方式以及线程的生命周期。 1. 创建线程 Java中创建线程主要有两种方式： **方式一：继承Thread类** 当你创建一个新的类继承自Thread类时，你需要重写run()方法。然后通过...
vc++中的线程锁（线程锁保持线程同步）
11-05
在提供的文件列表中，如`RWLock.cpp`，可能涉及到了读写锁（Read-Write Lock），这是一种更为复杂的线程同步机制，允许多个线程同时进行读操作，但只允许一个线程进行写操作，从而提高了并发性能。 `Thread.cpp`和`...
JAVA-多线程 所有文件
01-09
2. **创建线程**：在Java中，有两种主要方式创建线程：继承`Thread`类和实现`Runnable`接口。继承`Thread`类直接创建线程对象，而实现`Runnable`接口则可以避免单继承的限制，更灵活。 3. **启动线程**：通过调用`...
Java学习----同步代码块
hanxuya的博客
08-19 901
对于synchronized语句当Java源代码被javac编译成bytecode的时候，会在同步代码块的入口位置和退出位置分别插入monitorenter和monitorexit(2个)字节码指令。
java线程同步代码块_Java 线程同步代码块
weixin_42361018的博客
02-16 81
package test_02;/*进程: 进程就是正在运行的应用程序。 进程了负责了内存空间划分。线程： 一个进程中的代码是由线程去执行的，线程也就是进程中一个执行路径。多线程： 一个进程中有多个线程可以同时执行任务。多线程 的好处：1. 解决一个进程中可以同时执行多个任务的问题。2. 提高了资源利用率。多线程的弊端：1. 增加了cpu的负担。2. 降低了一个进程中线程 的执行概率。3. 出现了...
Java线程-同步代码块
琅枫的博客
02-02 206
Java线程中同步代码块这一内容比较重要的。 代码块是指用"{}"括起来的一段代码，根据其位置和声明的不同，可以分为普通代码块、构造块、静态块、和同步代码块。 如果在代码块前加上 synchronized关键字，则此代码块就成为同步代码块。 同步代码块的格式: synchronized(obj) { //需要被同步的代码块 } synchronized(同步监视器){ 需要同步的代码; } 其中，obj 称为同步监视器，也就是锁，原理是：当线程开始执行同步代码块前，必须先获得对同步代码块的锁定。
java定义一个同步代码块_Java 同步代码块
weixin_30249151的博客
03-02 125
public class ThreadDemo5 {public static void main(String[] args) {//开启四个线程 实现资源共享的目的TestThread4 testThread4 = new TestThread4();Thread thread = new Thread(testThread4);thread.start();//资源数据访问不同步new Th...
12.Java同步代码块
jianjun200607的专栏
11-20 526
翻译地址：http://tutorials.jenkov.com/java-concurrency/synchronized.html
线程同步
JustinNeil的博客
05-12 182
相关概念 同步指发送一个请求,需要等待返回,然后才能够发送下一个请求，有个等待过程 异步指发送一个请求,不需要等待返回,随时可以再发送下一个请求，即不需要等待 区别一个需要等待，一个不需要等待，在部分情况下，我们的项目开发中都会优先选择不需要等待的异步交互方式 同步是用于确保资源一次只能被一个线程使用的过程，同步对于单线程程序没有任何好处。使用同步比非同步的性能差三到四倍 什么时候要用同步？ ja...
java同步代码块和同步函数
每天进步一点点
10-20 1468
package thread.sync; /* * 需求:储户，两个，每个都到银行存钱每次存100，，共存三次。 */ public class BankDemo { public static void main(String[] args) { Cus c = new Cus(); System.out.println(c); //静态同步函数用此,该函数的字节码文件对象
Java线程同步实现方法
此博客不再更新，请访问： http://blog.csdn.net/qq_29078329
10-26 752
1        synchronized关键字 (1)    synchronized修饰代码块，一个线程访问一个对象的synchronized同步代码块时，其它试图访问该对象的线程将被阻塞，必须等待当前线程执行完这个代码块以后才能执行该代码块，但是另一个线程仍然可以访问该对象中的非synchronized同步代码块。一个线程在访问一个对象的synchronizedmethod1，其他的线
【Java基础笔记】线程.docx
10-25
本文档主要涵盖了Java SE（标准版）中的线程相关知识，包括线程的定义、生命周期、创建与使用方法以及线程同步策略。 一、线程基础 线程可以理解为进程内部的一个执行路径，每个线程拥有独立的运行栈和程序计数器...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值