【java笔记】进程和线程：线程同步，Lock锁

最新推荐文章于 2024-04-03 11:55:25 发布
最新推荐文章于 2024-04-03 11:55:25 发布
阅读量97 收藏
点赞数
文章标签： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/marcotsui/article/details/116707226
版权

进程：正在运行的程序
线程：执行路径
单线程程序：记事本
多线程程序：扫雷
多线程的实现方式：

package demo06;
/*
多线程的实现方法
1.定义Thread类重写run方法
2.创建Thread类的对象
3.启动多线程
*/
public class Demo01 {
    public static void main(String[] args) {
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        my1.start();
        my2.start();
    }
}


package demo06;
/*
创建一个新的执行线程有两种方法。 一个是将一个类声明为一个Thread的子类。 这个子类应该重写Thread类的方法run 。
 */
public class MyThread extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(i);
        }
    }
}

设置和获取线程名称：

package demo06;
/*
设置和获取线程名称：
 1.getName​() 返回此线程的名称。
 2.setName​(String name) 将此线程的名称更改为等于参数 name 。
 3.static Thread currentThread​() 返回对当前正在执行的线程对象的引用。
*/
public class Demo01 {
    public static void main(String[] args) {
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        my1.setName("飞机");
        my2.setName("高铁");
        my1.start();
        my2.start();
        System.out.println(Thread.currentThread());
    }
}


package demo06;
/*
创建一个新的执行线程有两种方法。 一个是将一个类声明为一个Thread的子类。 这个子类应该重写Thread类的方法run 。
 */
public class MyThread extends Thread {
    public void MyThread(){};
    public void MyThread(String name){};

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
        }
    }
}

多线程设置和获取优先级

package demo06;
/*
线程调度和线程优先级
1.int getPriority​() 返回此线程的优先级。
2.void setPriority​(int newPriority) 更改此线程的优先级。  优先级的范围1-10
注：优先级高只能表示调用CPU的几率高
*/
public class Demo01 {
    public static void main(String[] args) {
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        MyThread my3=new MyThread();
        my1.setName("飞机");
        my2.setName("高铁");
        my3.setName("汽车");

        my1.setPriority(10);
        my2.setPriority(5);
        my3.setPriority(1);

        my1.start();
        my2.start();
        my3.start();
    }
}

线程控制sleep

package demo06;
/*
线程控制
1.static void sleep​(long millis) 使当前正在执行的线程停留（暂停执行）指定的毫秒数，这取决于系统定时器和调度程序的精度和准确性。
 */
public class MyThread extends Thread {
    public void MyThread(){};
    public void MyThread(String name){};

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(getName()+":"+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

线程控制join：

package demo06;
/*
线程控制
2.void join​() 等待这个线程死亡。  
*/
public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        MyThread my3=new MyThread();
        my1.setName("飞机");
        my2.setName("高铁");
        my3.setName("汽车");
        

        my1.start();
        my1.join();
        my2.start();
        my3.start();
    }
}

线程控制3守护线程

package demo06;
/*
线程控制
3.void setDaemon​(boolean on) 将此线程标记为 daemon线程或用户线程。  守护线程
*/
public class Demo01 {
    public static void main(String[] args) throws InterruptedException {
        MyThread my1=new MyThread();
        MyThread my2=new MyThread();
        MyThread my3=new MyThread();
        my1.setName("关羽");
        my2.setName("张飞");
        //设置主线程
        Thread.currentThread().setName("刘备");
        //设置守护线程
        my1.setDaemon(true);
        my2.setDaemon(true);


        my1.start();
        my2.start();
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+","+i);

        }
    }
}

线程的生命周期
在这里插入图片描述
多线程的第二种实现方法：

package demo06;
/*
多线程的第二种实现方法：
1.定义一个类MyRunnable实现runnable接口
2.重写run方法
3.创建MyRunnable对象
4.创建Thread对象，将MyRunnable对象作为Thread对象的参数
5.启动线程
 */
public class Demo02 {
    public static void main(String[] args) {
        MyRunnable mr=new MyRunnable();
        MyRunnable mr2=new MyRunnable();
        Thread th1=new Thread(mr,"飞机");
        Thread th2=new Thread(mr2,"高铁");

        th1.start();
        th2.start();

    }
}

第二种方法的优点：
（1）解决java单继承的问题
（2）体现面向对象的思想，把线程和程序有效分离

卖票案例

package demo06;
/*
案例：卖票
 */
public class Demo03 {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();
        Thread th1=new Thread(st,"窗口1");
        Thread th2=new Thread(st,"窗口2");
        Thread th3=new Thread(st,"窗口3");
        th1.start();
        th2.start();
        th3.start();
    }
}


package demo06;

public class SellTicket implements Runnable {
    private int ticket=100;
    @Override
    public void run() {
        while (true){
            if(ticket>0){
                System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                ticket--;
            }
        }
    }
}

卖票案例的思考：

package demo06;
/*
案例：卖票案例的思考
使用Thread.sleep后
出现负数票和同一张票卖多次的现象
原因：线程的随机性
一票卖多次：在ticket--之前被另一个线程抢到CPU
负数票：在ticket--之后被另一个线程抢到CPU
 */
public class Demo03 {
    public static void main(String[] args) {
        SellTicket st=new SellTicket();
        Thread th1=new Thread(st,"窗口1");
        Thread th2=new Thread(st,"窗口2");
        Thread th3=new Thread(st,"窗口3");
        th1.start();
        th2.start();
        th3.start();
    }
}
  1. 线程同步
    synchronized解决数据安全问题：
package demo06;

public class SellTicket implements Runnable {
    private int ticket=100;
    Object obj=new Object();
    @Override
    public void run() {
        while (true){
            synchronized (obj){
            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                ticket--;
            }
        }
}
}}

优点：各个线程分开
缺点：各个线程都会去判断同步上的锁，耗费资源

同步方法的锁对象：this

package demo06;

public class SellTicket implements Runnable {
    private int ticket=100;
    private int x=0;
    Object obj=new Object();
    @Override
    public void run() {
        while (true){
            if(x%2==0){
            synchronized (this){
            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                ticket--;
            }
        }
}else{
                sellTicket();
                x++;
            }
}}

    private synchronized void sellTicket() {
  
            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                ticket--;
            }
        }


    }

静态同步方法的锁对象：类名.class

package demo06;

public class SellTicket implements Runnable {
    private static int ticket=100;
    private int x=0;
    Object obj=new Object();
    @Override
    public void run() {
        while (true){
            if(x%2==0){
            synchronized (SellTicket.class){
            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                ticket--;
            }
        }
}else{
                sellTicket();
                x++;
            }
}}

    private synchronized static void sellTicket() {

            if(ticket>0){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                ticket--;
            }
        }


    }

线程安全的类：

package demo06;

import java.util.*;

/*
线程安全的类
StringBuffer
Vector
Hashtable
 */
public class Demo04 {
    public static void main(String[] args) {
        StringBuilder sb=new StringBuilder();
        StringBuffer sbb=new StringBuffer();

        Vector<String> ve=new Vector<>();
        ArrayList<String> arr=new ArrayList<>();

        Hashtable<String,String> ht=new Hashtable<>();
        HashMap<String,Integer> hm=new HashMap<>();

        //更常用的static <T> List<T> synchronizedList​(List<T> list) 返回由指定列表支持的同步（线程安全）列表。
        List<String> strings = Collections.synchronizedList(new ArrayList<String> ());
    }
}

Lock锁：

package demo06;


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

/*
lock的使用：
void lock​() 获得锁。
void unlock​() 释放锁。
构造方法：ReentrantLock​() 创建一个 ReentrantLock的实例。
 */
public class SellTicket implements Runnable {
    private int ticket=100;
    private Lock lock =new ReentrantLock();
    @Override
    public void run() {
        while (true){
                try{
                    lock.lock();
                    if(ticket>0){
                        try {
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"正在出售第"+ticket+"张票");
                        ticket--;
                    }
                }finally {
                    lock.unlock();
                }

            }
        }
    }

生产者和消费者模式概述：
Object类中的等待和唤醒方法：
1.void wait​() 导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法。
2.void notify​() 唤醒正在等待对象监视器的单个线程。
3.void notifyAll​() 唤醒正在等待对象监视器的所有线程。

？案例：生产者和消费者案例

码布里
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
利用redis生成注解实现进程锁
02-08
利用redis生成注解实现进程锁
关于锁的思考及总结（线程锁，进程锁，分布式锁）
m0_57456259的博客
01-25 1033
Java 中提供了种类丰富的锁，每种锁因有不同的特性在不同的场景能够展现出较高的性能。
Java并发-线程与进程、线程安全、锁、阻塞队列详解，看这一篇就够了
一个编程爱好者的博客
03-19 820
但是在多线程的情况下，一个线程可能在步骤1和步骤2完毕以后，线程失去CPU进入就绪状态，CPU切换到另外一个线程，另外一个线程执行相同操作，那么在该线程的操作中，仅仅只运行到了步骤1，随即线程2被剥夺运行权，此时切换到线程1，继续执行步骤3，操作完毕以后，线程2开始运行，此时计算的账户金额，是以第一次运行时读取的账户余额为基础计算的，那么重新写回账户的金额就会出错，即将线程1的操作进行覆盖，钱款会存在丢失的情况。由于还没有分配CPU，线程将进入线程队列排队，等待CPU服务，这表明它已经具备了运行条件。
Java中15种锁介绍
2301_78008478的博客
06-13 2831
lock（)方法利用的CAS，当第一个线程A获取锁的时候，能够成功获取到，不会进入while循环，如果此时线程A没有释放锁，另一个线程B又来获取锁，此时由于不满足CAS，所以就会进入while循环，不断判断是否满足CAS，直到A线程调用unlock方法释放了该锁。代码也比较简单，使用原子引用来存放线程，同一线程两次调用lock()方法，如果不执行unlock()释放锁的话，第二次调用自旋的时候就会产生死锁，这个锁就不是可重入的，而实际上同一个线程不必每次都去释放锁再来获取锁，这样的调度切换是很耗资源的。
java的进程和加锁
汪程序员
06-04 694
代码 每次无法到达20000，因为存在进程之间未同步，可能线程1正在对count加1，但是突然线程2到来，线程1还未来的及加1。在方法前加synchronized,就可以实现同步20000。
java线程笔记
05-06
以上就是关于"java线程笔记"中的主要知识点，涵盖了线程的创建、同步、单例模式、锁机制、线程通信以及线程池等方面，这些都是Java并发编程的基础和核心。通过深入理解并熟练运用这些概念，可以编写出高效、稳定的多...
Java多线程源码笔记.pdf
05-08
7. 线程池：Java提供了ExecutorService和ThreadPoolExecutor等工具来管理线程池，线程池可以有效控制运行的线程数量，避免频繁创建销毁线程的开销，提高响应速度和系统资源利用率。 8. 死锁：当两个或更多线程互相...
JAVA并发编程实践-线程安全-学习笔记
07-20
另外，Java的并发包`java.util.concurrent`引入了显式锁（如`Lock`接口及其实现类），以及原语操作（如Atomic类），这些都为开发者提供了更细粒度的控制，可以在不使用synchronized的情况下实现线程安全。...
Java多线程自学笔记
01-19
### Java多线程自学笔记知识点总结 ...理解和掌握多线程的基本概念、创建方式以及线程间的通信、同步机制等对于开发高性能的Java应用至关重要。希望这份笔记能够帮助读者更好地理解Java多线程的相关知识。
Java 并发学习笔记：进程和线程，并发理论，并发关键字，Lock 体系，原子操作类，发容器 & 并发工具，线程池，并发实践
12-26
进程和线程， 并发理论， 并发关键字， Lock 体系， 原子操作类， 发容器 & 并发工具， 线程池， 并发实践 Java是一种面向对象的编程语言，由Sun Microsystems于1995年推出。它是一种跨平台的语言，意味着可以在...
java synchronized加载加锁-线程可重入详解及实例代码
08-31
主要介绍了java synchronized加载加锁-线程可重入详解及实例代码的相关资料,需要的朋友可以参考下
Java多线程、并发、进程和锁的详细讲解
qq_36095290的博客
03-05 1032
Java多线程、并发、进程、死锁、同步锁、线程的创建方式
Java中各种死锁详细讲述及其解决方案（图文并茂，浅显易懂
最新发布
2401_83329402的博客
04-03 938
Java面试核心知识点一共有30个专题，足够读者朋友们应付面试啦，也节省朋友们去到处搜刮资料自己整理的时间！Java面试核心知识点已经有读者朋友靠着这一份Java面试知识点指导拿到不错的offer了《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！057)][外链图片转存中…(img-mmXckZf2-1712116511057)]
Java多线程详解（九）Lock锁的使用
筱寒小记
06-11 1594
Lock（锁） 从JDK5.0开始，Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当 java.util.locks.Lock接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对Lock对象加锁，线程开始访问共享资源之前应先获得Lock对象 ReentrantLock类实现了Lock，它拥有与synchronized相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是ReentranrLock，可
Java 进程间文件锁FileLock详解
我的专栏
09-18 3万+
最近需要在两个进程中对同一个文件进行操作，正好Java 提供了文件锁FileLock类，利用这个类可以控制不同程序（JVM）对同一文件的并发访问，实现进程间文件同步操作。 FileLock是java 1.4 版本后出现的一个类，它可以通过对一个可写文件(w)加锁，保证同时只有一个进程可以拿到文件的锁，这个进程从而可以对文件做访问；而其它拿不到锁的进程要么选择被挂起等待，要么选择去做一些其它的
java 共享锁_Java进程间共享锁
weixin_33578569的博客
02-16 748
背景业务系统运行时产生了大量的小文件(大小在10kb左右，包含一些表单的内容，rest接口的访问记录)，考虑到将这些内容存储在数据库中对数据库压力较大，因此转为文件存储，但由于restful接口访问频繁，导致产生了大量的小文件，最终导致服务器inode占用率过高，触发告警原因什么是inode?inode包含文件的元信息，具体来说有以下内容：* 文件的字节数* 文件拥有者的User ID* 文件的G...
JAVA 并发与锁机制原理
lxlmycsdnfree的博客
01-03 1104
Lock完全用Java写成，在java这个层面是无关JVM实现的。 在java.util.concurrent.locks包中有很多Lock的实现类，常用的有ReentrantLock、ReadWriteLock（实现类ReentrantReadWriteLock），其实现都依赖java.util.concurrent.AbstractQueuedSynchronizer类，实现思路都大同小异，...
Java线程(八)：锁对象Lock-同步问题更完美的处理方式
热门推荐
寻道
04-14 11万+
Lock是java.util.concurrent.locks包下的接口，Lock 实现提供了比使用synchronized 方法和语句可获得的更广泛的锁定操作，它能以更优雅的方式处理线程同步问题，我们拿Java线程(二)中的一个例子简单的实现一下和sychronized一样的效果，代码如下： public class LockTest { public static voi...
Java多线程入门7-线程同步锁机制sysnchronized和Lock
jinyangjie的博客
01-02 699
使用多线程，不可避免会碰上同个资源争抢的问题，即线程同步问题。比如节假日的抢票，多个人同时申请买票时，都会让票数减一，如何确保票数正确，不会发生超卖问题？Java提供了两种同步锁机制，synchronzied和Lock锁。
Java JUC并发编程笔记：进程与线程、锁机制详解
本文档是一份关于Java并发编程（JUC）的学习笔记，主要涵盖了进程与线程的基本概念、Java中线程的创建和管理以及并发和并行的区别，重点讨论了Lock（锁）在并发编程中的作用。以下是详细的内容概述： 1. 进程和线程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值