Java中线程的基本理解和synchronized关键字使用

最新推荐文章于 2024-10-16 10:13:45 发布
最新推荐文章于 2024-10-16 10:13:45 发布
阅读量64 收藏
点赞数 1
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44865618/article/details/130332700
版权

Java中线程的实现方式

  1. 继承Thread类，重写run方法。在run方法中实现具体逻辑
    public class ExtendThread {
    public static void main(String[] args) {
    ThreadTest threadTest = new ThreadTest();
    threadTest.start();
    }
    }
    class ThreadTest extends Thread{
    @Override
    public void run() {
    System.out.println(“thread”);
    }
    }
  2. 实现runnable接口。
    public class RunnableTest {
    public static void main(String[] args) {
    ThreadImRunnable runnable = new ThreadImRunnable();
    Thread thread = new Thread(runnable);
    thread.start();
    for (int i = 0; i < 10; i++) {
    System.out.println(Thread.currentThread().getName()+“main***********”+i);
    }
    }

}
class ThreadImRunnable implements Runnable{
@Override
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(“我是Runnable”+i);
}

}

}

线程和进程理解
● 只有当所有线程结束，进程才会结束
● start()开启多线程。最终调用jvm的start0(),使该线程处于可运行状态。等待cpu调度。
● 主线程启动子线程的运行。只有当主线程和子线程都结束了。整个进程才会结束。
● 继承Thread和实现Runnable接口的区别。继承Thread类只能线程独享资源。每个Thread都会创建新的资源。实现Runnable接口可以实现多线程共享资源的情况。避免了但继承的限制。
通知线程退出
在实现Runnable接口的或者继承Thread的类里面添加一个属性，并且设置getset方法。在主线程某个时刻修改这个属性。使其停止执行。
public class ThreadExit {
public static void main(String[] args) throws InterruptedException {
ThreadExit_ threadExit_ = new ThreadExit_();
threadExit_.start();

    Thread.sleep(5*1000);
    //设置为false，满足使其停止循环的条件。退出线程
    threadExit_.setLoop(false);

}

}
class ThreadExit_ extends Thread{
private int count = 0;

public void setLoop(boolean loop) {
    this.loop = loop;
}

//通知线程终止属性
private boolean loop = true;
@Override
public void run() {

    while (loop){
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("子线程"+(++count));

    }
}

}
线程的礼让和插入
线程礼让：指的是某一个线程礼让另一个线程。但是只是让出竞争资源。实际还要根据cpu调度来看。礼让不一定成功。也有可能两个线程还是同时执行

线程插入：指的是某一个线程执行Thread.join()方法。停止执行当前线程。直到join进来的线程全部执行完毕再执行之前的线程。
public class JoinThread {
public static void main(String[] args) throws InterruptedException {
ThreadJoin threadJoin = new ThreadJoin();
threadJoin.start();
for (int i = 0; i < 20; i++) {
System.out.println(“主线程在吃包子”+i);
Thread.sleep(1000);
if(i==10){
System.out.println(“主线程让子线程插队吃”);
//执行join方法
threadJoin.join();
}
}
}
}
class ThreadJoin extends Thread{
@Override
public void run() {
for (int i = 0; i < 20; i++) {
System.out.println(“子线程在吃包子”+i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
用户线程和守护线程
用户线程：也叫工作线程，正常执行完或者以通知方式退出。
守护线程：当所有线程执行完，该线程也会自动退出。
使用实例：垃圾回收机制
public class DeamonThread {
public static void main(String[] args) throws InterruptedException {
T t = new T();

    Thread thread = new Thread(t);
    //设置为守护线程。注意要在线程启动之前
    thread.setDaemon(true);
    thread.start();

    for (int i = 0; i < 10; i++) {
        Thread.sleep(1000);
        System.out.println("俺们在干活");
    }

}

}
class T implements Runnable{

@Override
public void run() {
    for(;;){
        try {
            Thread.sleep(1000);
            System.out.println("俺们在聊天");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

}
使用synchronized�买卖售票问题
public class SellThread {
public static void main(String[] args) {
SellTicketThread sellTicketThread01 = new SellTicketThread();
SellTicketThread sellTicketThread02 = new SellTicketThread();
SellTicketThread sellTicketThread03 = new SellTicketThread();
sellTicketThread01.start();
sellTicketThread02.start();
sellTicketThread03.start();
// SellTicketIm sellTicketIm = new SellTicketIm();
// new Thread(sellTicketIm).start();
// new Thread(sellTicketIm).start();
// new Thread(sellTicketIm).start();
}
}
class SellTicketThread extends Thread{
//继承Thread类的方式售票。
//因为每次都是新创建实例开启线程(创建多个实例对象)。要将售卖方法，
// 还有对应变量都要置为静态变量(这样方法和类变量就不受创建实例的数量影响。归类元信息所有)。以供多个线程共享资源。
public static int num = 300;
public static boolean loop = true;

private static synchronized void sell(){
    try {
        Thread.sleep(50);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    if (num<=0){
        loop = false;
        System.out.println("票卖完了");
        return;
    }
    System.out.println("窗口"+Thread.currentThread().getName()+"售卖了一张票，当前窗口余票为"+(--num));
}

@Override
 public  void run() {
    while (loop){
        sell();
    }
}

}
class SellTicketIm implements Runnable{
//实现Runnable接口的方式售票。
//实例只创建一次。交由多个线程来跑。这个实例就相当于共享资源，所以不需要将内部变量和方法置为静态类型。
// 只需将售卖方法用synchronized修饰。保证该方法同一时刻只有一个线程可以访问，其他线程为等待状态。
public int num = 1000;
public boolean loop = true;
private synchronized void sell(){
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num<=0){
loop = false;
System.out.println(“票卖完了”);
return;
}
System.out.println(“窗口”+Thread.currentThread().getName()+“售卖了一张票，当前窗口余票为”+(–num));
}
@Override
public void run() {
while (loop){
sell();
}
}
}
线程常用方法
setName()//使线程名字与传入参数相同
getName()//获取线程名称
sleep()//使当前线程休眠给定毫秒时间。（暂停执行）
start()//使该线程开始执行(准确的说是获得可运行状态。等待cpu调度)。底层jvm调用start0()
run()//调用线程对象run方法
setPriority()//设置线程优先级
getPriority()//获取线程优先级
interrupt()//线程中断
互斥锁
线程之间的争抢只能是同一个引用，如果都是独立的引用则会产生无效的争抢。使用synchronzied修饰代码块或者类进行线程互斥。
实现互斥锁的步骤

  1. 分析需要上锁的代码
  2. 选择同步代码块或者同步方法。
  3. 保证多线程锁对象为同一个即可。即synchronzied(a)。a为多个线程共享资源即可。
  4. 采用继承Thread类和实现Runnable接口来保证互斥锁的方式不同。(尽量选择同步代码块来保证互斥。)
    ○ 继承Thread类开启线程要实例化三个实体。每个实体都有自己的属性。最好是把私有属性都用static修饰。
    ○ 实现Runnable接口只需要中需要synchronzied()修饰的同步代码或者同步方法的位置即可。因为只需要实例化一个实体。非静态同步方法的锁可以是this。也可以是其他对象（要求为同一对象）。静态同步方法的锁是当前类的Class对象。
    代码示例
    [ ] 继承Thread类非静态代码块
    public class SellThread {
    public static void main(String[] args) {
    SellTicketThread sellTicketThread01 = new SellTicketThread();
    SellTicketThread sellTicketThread02 = new SellTicketThread();
    SellTicketThread sellTicketThread03 = new SellTicketThread();
    sellTicketThread01.start();
    sellTicketThread02.start();
    sellTicketThread03.start();

// SellTicketIm sellTicketIm = new SellTicketIm();
// new Thread(sellTicketIm).start();
// new Thread(sellTicketIm).start();
// new Thread(sellTicketIm).start();
}
}
class SellTicketThread extends Thread{
//继承Thread类的方式售票。
//因为每次都是新创建实例开启线程(创建多个实例对象)。要将售卖方法，
// 还有对应变量最好置为静态变量(这样方法和类变量就不受创建实例的数量影响。归类元信息所有)。以供多个线程共享资源。
public static int num = 100;
public static boolean loop = true;

private void sell(){
    //这里如果用this则会出现超卖或重复卖现象。synchronized修饰静态代码块
    //使用SellTicketThread.class是为了获取类元信息。使多个线程共享这一个资源。进行锁竞争。形成互斥锁。
    synchronized(SellTicketThread.class){
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (num<=0){
            loop = false;
            System.out.println("票卖完了");
            return;
        }
        System.out.println("窗口"+Thread.currentThread().getName()+"售卖了一张票，当前窗口余票为"+(--num));
    }

}

@Override
 public  void run() {
    while (loop){
        sell();
    }
}

}
[ ] 继承Thread类非静态方法(普通方法)
public class SellThread {
public static void main(String[] args) {
SellTicketThread sellTicketThread01 = new SellTicketThread();
SellTicketThread sellTicketThread02 = new SellTicketThread();
SellTicketThread sellTicketThread03 = new SellTicketThread();
sellTicketThread01.start();
sellTicketThread02.start();
sellTicketThread03.start();

// SellTicketIm sellTicketIm = new SellTicketIm();
// new Thread(sellTicketIm).start();
// new Thread(sellTicketIm).start();
// new Thread(sellTicketIm).start();
}
}
class SellTicketThread extends Thread{
//继承Thread类的方式售票。
//因为每次都是新创建实例开启线程(创建多个实例对象)。要将售卖方法，
// 还有对应变量都要置为静态变量(这样方法和类变量就不受创建实例的数量影响。归类元信息所有)。以供多个线程共享资源。
public static int num = 100;
public static boolean loop = true;

private synchronized void sell(){
    //synchronized修饰普通方法
    //使用SellTicketThread.class是为了获取类元信息。使多个线程共享这一个资源。进行锁竞争。形成互斥锁。

// synchronized(SellTicketThread.class){
//
// }
try {
Thread.sleep(50);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num<=0){
loop = false;
System.out.println(“票卖完了”);
return;
}
System.out.println(“窗口”+Thread.currentThread().getName()+“售卖了一张票，当前窗口余票为”+(–num));

}

@Override
 public  void run() {
    while (loop){
        sell();
    }
}

}
[ ] 静态方法
public class SellThread {
public static void main(String[] args) {
// SellTicketThread sellTicketThread01 = new SellTicketThread();
// SellTicketThread sellTicketThread02 = new SellTicketThread();
// SellTicketThread sellTicketThread03 = new SellTicketThread();
// sellTicketThread01.start();
// sellTicketThread02.start();
// sellTicketThread03.start();

    SellTicketIm sellTicketIm = new SellTicketIm();
    new Thread(sellTicketIm).start();
    new Thread(sellTicketIm).start();
    new Thread(sellTicketIm).start();
}

}
class SellTicketIm implements Runnable{
//实现Runnable接口的方式售票。
//实例只创建一次。交由多个线程来跑。这个实例就相当于共享资源，所以不需要将内部变量和方法置为静态类型。
// 只需将sell()用synchronized修饰。保证该方法同一时刻只有一个线程可以访问，其他线程为等待状态。
public int num = 100;
public boolean loop = true;
private synchronized static void sell(){
try {
Thread.sleep(5);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (num<=0){
loop = false;
System.out.println(“票卖完了”);
return;
}
System.out.println(“窗口”+Thread.currentThread().getName()+“售卖了一张票，当前窗口余票为”+(–num));
}

咖啡不苦么
关注
Java中synchronized关键字的使用和原理
盛夏温暖流年
09-29 1065
synchronized关键字的使用 synchronized 关键字是 Java 中一个独占式的悲观锁，可以用来修饰方法块和方法，根据锁定对象的类型进行分类，可以分为对象锁和类锁。 对象锁 修饰同步代码块：锁定对象为 this 或者实例对象； public class Sync{ private int a = 0; public void add(){ // 锁定对象为 this synchronized(this){
java多线程编程之使用Synchronized关键字同步类方法
09-04
总之，`synchronized`关键字是Java多线程编程中处理并发问题的关键手段，它可以确保共享资源在同一时刻只被一个线程访问，从而维护数据的一致性和正确性。理解其工作原理以及如何在不同场景下正确使用，对于编写健壮...
synchronized 方法 synchronized关键字详解
favomj的博客
11-01 426
synchronized 关键字，代表这个方法加锁,相当于不管哪一个线程A每次运行到这个方法时,都要检查有没有其它正在用这个方法的线程B（或者C D等）,有的话要等正在使用这个方法的线程B（或者C D）运行完这个方法后再运行此线程A,没有的话,直接运行 它包括两种用法：synchronized 方法和 synchronized 块。 1. synchronized 方法： 　　通过在方法声
synchronized关键字的使用
m0_63463465的博客
12-06 169
synchronized是Java的一个关键字，实际使用对象锁保证了临界区代码的原子性，是线程同步的一种方式。synchronized可以修饰方法或者代码块，当修饰方法时锁住的是整个方法(实际锁住的是当前对象，保证了整个方法的原子性)，如果修饰的方法是静态方法会锁住整个类(锁的是类对象)。修饰代码块时只锁代码块。注意：不可以修饰静态代码块。 可见，当线程1进入方法时，在线程1执行结束前，线程2无法进入该方法中。如果去掉 synchronized 修饰可以看到两个线程均进入方法中。由
Synchronized关键字加在方法上和类上的区别
qq_46130027的博客
05-12 1833
也就是说，当一个线程获取该类的锁后，其他线程将不能访问该类的任何synchronized方法或代码块。这种方式比较少见，因为它可能会对程序性能产生一定的影响，而且它只能保证同一时刻只有一个线程访问该类的所有synchronized方法或代码块。也就是说，该方法只能在一个线程执行完之后，其他线程才能继续执行该方法或该对象的其他synchronized方法。synchronized关键字可以用于控制多线程对共享资源的访问，它有两种用法：一种是将其加在方法上，另一种是将其加在代码块上。
Java synchronized关键字实现线程同步
WYSCODER的博客
04-02 6324
synchronized关键字实现线程同步
深入理解Java中的synchronized关键字
weixin_74268571的博客
06-15 1474
synchronized的详细讲解和底层实现，以及synchronized的同步机制，synchronized的重入和synchronized的异常演示
Java中Synchronized关键字详解及使用
Cavewang的博客
10-07 1656
Java中Synchronized关键字详解及使用
java多线程-Synchronized关键字详解
lijianbiao0的博客
05-30 739
Synchronized关键字开篇定义作用应用场景原理具体使用使用方式特别注意其他控制并发 / 线程同步方式Lock、ReentrantLock简介区别Compare And Swap（CAS）定义：原理优点典型应用：AtomicInteger 开篇 在Java中，有一个常被忽略 但 非常重要的关键字Synchronized 今天，我将详细讲解 Java关键字Synchronized的所有知识，希...
java中synchronized关键字
龙空白白的博客
06-10 4067
synchronized是java中的一个关键字，在中文中为同步，也被称之为’同步锁’,以此来达到多线程并发访问时候的并发安全问题，可以用来修饰代码块、非静态方法。静态方法等； 修饰代码块时:给当前指定的对象加锁 修饰非静态方法时:作用于当前实例加锁 修饰静态方法时:作用于当前类对象加锁 synchronized在java内存模型中的主要作用 原子性:通过monitorenter和monitorexit指令,保证被synchronized修饰的代码在同一时间只能被一个线程访问，在锁未释放之前，无法被其他线程
理解Java中的synchronized关键字
weixin_43104619的博客
11-26 961
一、为什么需要synchronized关键字 在java中，免不了为了提升效率而使用多线程，而使用了多线程，就可能会出现线程不安全，导致数据错误等结果，在这种情况下，为了防止多线程下 线程不安全，就会采用synchronized（当然也有其他方法），使用synchronized的关键就是他会获取锁，在一个线程拥有锁的情况下，另一个线程只能等待，直到第一个线程释放了锁才能进入被synchroniz...
java的线程同步机制synchronized关键字的理解_.docx
10-09
Java 线程同步机制中 synchronized 关键字的理解 Java 的线程同步机制是为了解决多个线程共享同一片存储空间所带来的访问冲突问题。其中，synchronized 关键字是 Java 语言中解决这种冲突的重要机制。 ...
java基本教程之synchronized关键字 java多线程教程
09-04
理解并正确使用synchronized关键字是Java多线程编程的关键，它可以帮助开发者防止数据不一致性和线程竞态条件，确保多线程环境下的数据安全。然而，过度使用synchronized可能导致性能下降，因此需要根据具体应用场景...
深入讲解java线程与synchronized关键字
08-31
本文将详细讲解Java线程的基本概念、创建线程的方式以及synchronized关键字的使用和特性。 1. **线程的基本概念** 在操作系统中，进程是资源分配的基本单位，而线程则是执行的基本单位。一个进程中可以包含多个...
Java多线程并发编程 Synchronized关键字
08-30
Java中的`synchronized`关键字是多线程编程中用于实现线程同步的重要机制，它确保了在多线程环境下对共享资源的访问具有互斥性和可见性。这些特性使得`synchronized`成为解决并发问题的关键工具。 1. **同步锁机制*...
【C++刷题】力扣-#121-买卖股票的最佳时机
最新发布
会写代码的饭桶
10-16 231
给定一个数组 prices，其中 prices[i] 表示第 i 天的股票价格。假设你可以在第 i 天买入并在第 j 天卖出股票（i ≤ j），设计一个算法来计算你所能获取的最大利润。注意你只能持有一股股票，并且你不能同时参与多笔交易（即在再次买入前必须卖出股票）。
基于SSM班级事务管理系统的设计
2401_87849773的博客
10-15 290
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
2024.10月12日--- SpringMVC异常处理
whisper_Java 的博客
10-12 912
*** 用户【】 IP[]* 在【时间】* 操作【Controller.find】 发生如下异常*/@OverrideSystem.out.println("---------执行了自定义异常处理器------------");// 根据不同的异常类型，设置不同的响应状态码// 可以添加更多的自定义处理逻辑//}else {// 记录日志或其他处理逻辑// 可以将异常信息放入模型中供视图展示。
Backend - Java 基础
是萝卜干呀的博客
10-11 837
知识量决定了未来能走多远
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值