线程和正则表达式

最新推荐文章于 2023-05-15 22:30:56 发布
最新推荐文章于 2023-05-15 22:30:56 发布
阅读量345 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huashui16318/article/details/47099611
版权

正则表达式

正则表达式通常用于判断语句中，用来检查某一字符串是否满足某一格式。
接下来用几个常用例子来说明正则表达式的具体用法。

package com.lingzhuo.Test;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ZhengZe {
    public static void main(String[] args) {
        //邮箱
    /*  Pattern p=Pattern.compile("\\w+@\\w+(\\.\\w{2,3})*\\.\\w{2,3}");
        Matcher m=p.matcher("123@qq.com.cn");
        boolean b=m.matches();
        System.out.println(b);*/
        //电话号码
        /*Pattern p=Pattern.compile("^((13)|(15)|(18)|(17))\\d{9}$");
        Matcher m=p.matcher("13140168171");
        System.out.println(m.matches());*/
        //身份证号
        Pattern p=Pattern.compile("^\\d{17}(\\d{1}|x)$");
        Matcher m=p.matcher("12345678912345678x");
        System.out.println(m.matches());
        //密码6到8位字母数字下划线组合
        /*Pattern p=Pattern.compile("^\\w{6,8}$");
        Matcher m=p.matcher("13_6zzz");
        System.out.println(m.matches());*/
    }
}

在上边的代码中，实现了判断邮箱是否符合邮箱的基本格式，电话号码是否符合一般的电话号码形式，还有平时使用密码格式。
这里写图片描述
这里写图片描述
这里举出了常见的基本的集中正则表达式。

线程

在java中主要提供两种方式实现线程，分别为集成java.lang.Thread类与实现java.lang.Runnable接口。

继承Thread类

package com.lingzhuo.Thread;

public class SellTicketsThread extends Thread{
    @Override
    public void run() {
        // TODO Auto-generated method stub
        for (int i = 1; i < 11; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().toString()+i);
        }
    }
}

实现runnable接口

package com.lingzhuo.Thread;

public class SellRunnable implements Runnable {
    int i = 100;
    String str = "abc";

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (i > 0) {
            try {
                Thread.sleep(100);// 休眠100ms;
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } // 四个线程进入while循环之后，先进行休眠，使得进入锁的线程执行完之后不能立即与其他三个线程抢占锁。
                // （解决运行速度太快的问题）
            sell();
        }
    }
    private synchronized void sell() {
        if (i > 0) {
            System.out.println(Thread.currentThread().toString() + i);
            i--;
        }
    }
}

对两种方式进行测试：

package com.lingzhuo.Thread;

public class ThreadTest {
    public static void main(String[] args) {
        //对Thread类进行测试
        /*SellTicketsThread th1=new SellTicketsThread();
        SellTicketsThread th2=new SellTicketsThread();
        th1.start();
        th2.start();*/
        //对实现runnable接口进行测试
        SellRunnable sr=new SellRunnable();
        Thread thread1=new Thread(sr);
        Thread thread2=new Thread(sr);
        Thread thread3=new Thread(sr);
        Thread thread4=new Thread(sr);
        thread1.start();
        thread2.start();
        thread3.start();
        thread4.start();
    }
}

这里写图片描述
这里写图片描述
1. 由运行结果可以看出，在继承Thread类中，会出现同一件事情被两个线程都运行了一次。
2. 为解决这样的问题，采用了实现runnable接口，实现数据共享。但是这中间还有问题就是由于线程运行较快，抢占CPU的顺序不确定，使得某些事情运行不到，而有些事情被多次运行。
3. 鉴于这种问题，这里使用了锁，当某一个线程进入run运行，其他线程只能等待。关键字为synchronized。

线程的wait()方法

package com.lingzhuo.Thread;

public class WaitThread implements Runnable{
    String s="abc";
    public WaitThread() {
        // TODO Auto-generated constructor stub
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("进入等待run");
        synchronized (s) {
            System.out.println("等待前");
            try {
                s.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("等待后");
        }
    }
}

线程的唤醒

package com.lingzhuo.Thread;

public class NotifyThread implements Runnable{
    String s="abc";
    public NotifyThread() {
        // TODO Auto-generated constructor stub
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        System.out.println("进入唤醒run");
        synchronized (s) {
            System.out.println("唤醒前");
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            s.notify();
            System.out.println("唤醒后");
        }
    }

}

这里写图片描述

package com.lingzhuo.Thread;

public class NotifyWaitTest {
    public static void main(String[] args) {
        Thread t1=new Thread(new WaitThread());
        Thread t2=new Thread(new NotifyThread());
        t1.start();
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        t2.start();
    }
}

线程的加入

package com.lingzhuo.Thread;

public class JoinTest {
    public static void main(String[] args) {
        Thread t=new Thread(new SellRunnable());
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("程序运行完成");
    }
}

运行结果：
这里写图片描述

线程中的死锁

package com.lingzhuo.Thread;

public class SiSuoThread implements Runnable {

    String s1;
    String s2;

    public SiSuoThread(String s11,String s22){
        this.s1=s11;
        this.s2=s22;
    }

    public void run() {
        synchronized(s1){
            System.out.println(Thread.currentThread().toString()+"持有第一个锁"+s1);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized (s2) {
                System.out.println(Thread.currentThread().toString()+"持有第二个锁"+s2);
            }
        }
    }
}

package com.lingzhuo.Thread;

public class SiSuoTest {
    public static void main(String[] args) {
        String s1="abc";
        String s2="def";
        String s3="ghi";
        Thread thread1=new Thread(new SiSuoThread(s1,s2), "thread1");
        Thread thread2=new Thread(new SiSuoThread(s2,s3), "thread2");
        Thread thread3=new Thread(new SiSuoThread(s3,s1), "thread3");
        thread1.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        thread2.start();
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        thread3.start();
    }
}

运行结果：
这里写图片描述

wait（）和notify（）方式的一个实例

生产者
package com.lingzhuo.Thread;

public class ProductedThread implements Runnable{
    ShengchanXiaofei sf2;
    public ProductedThread(ShengchanXiaofei sf) {
        // TODO Auto-generated constructor stub
        this.sf2=sf;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            sf2.product();
        }   
    }   
}

消费者
package com.lingzhuo.Thread;

public class ConsumerThread implements Runnable{
    ShengchanXiaofei sf1;
    public ConsumerThread(ShengchanXiaofei sf) {
        // TODO Auto-generated constructor stub
        this.sf1=sf;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        while(true){
            sf1.consumer();
        }   
    }

}

生产消费关系类
package com.lingzhuo.Thread;

public class ShengchanXiaofei {
    boolean ishave=false;
    public synchronized void product(){
        if(!ishave){
            System.out.println("开始生产");         
                shuiMian();
            System.out.println("生产完成");
            notify();
            shuiMian();
            ishave=true;
        }
    }
    public synchronized void consumer(){
        if(!ishave){
            System.out.println("没有产品，等待");
            try {
                wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            System.out.println("消费");
            shuiMian();
        }
        System.out.println("消费完成");
        ishave=false;
        notify();
        shuiMian();
        shuiMian();
    }
    public static void shuiMian(){
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

测试类
package com.lingzhuo.Thread;

public class ShengchanXiaofeiTest {
    public static void main(String[] args) {
        ShengchanXiaofei sf=new ShengchanXiaofei();
        Thread t1=new Thread(new ConsumerThread(sf));
        Thread t2=new Thread(new ProductedThread(sf));      
        t1.start();
        ShengchanXiaofei.shuiMian();
        t2.start();
    }
}

运行结果：
这里写图片描述

huashui16318
关注
Jmeter之必备的正则表达式和正则表达式提取器
qq_55482452的博客
07-16 514
1.正则表达式 https://www.runoob.com/regexp/regexp-syntax.html 2.常用的正则表达式(元字符+限定符) 3.校验正则表达式是否正确？ 可以在在线的正则表达式来校验自己写的正则表达式是否能匹配到字符 https://c.runoob.com/front-end/854 4.正则表达式提取器(元件) 位置？作用？ 4.1添加正则表达式路径：...
WinForm使用正则表达式提取内容的方法示例
08-30
文章还提到了几个正则表达式在线工具的链接，这些工具可以帮助用户测试和生成正则表达式，非常便于开发者在编写代码前进行调试和验证正则表达式的正确性。 最后，文章提到了若干C#和WinForm相关的教程与专题，对于...
线程，正则表达式
J_songchao的博客
03-06 396
线程同步 同时对数据进行修改防止并发 锁使多线程任务更加安全 Condition：上锁(acquire())等待(wait())解锁(release())唤醒(notify(),notify_all()) 创键锁：lock=threading.Lock() threading.Condition(lock=Lock)import threading import time lock...
线程and正则表达式
w605771262的博客
03-07 191
import threading #导入threading模块import time #导入时间模块 time.sleep()控制间隔时长线程同步：当多个线程同时进行的时候.线程锁：lock = threading.Lock()#创建锁             cond = threading.Condition(lock=lock)#把锁赋给变量cond由于并发的原因，所以必须上锁：Condit...
线程和正则
lt0318aa的博客
03-08 130
#线程的五种状态 创建， 就绪， 运行，阻塞，死亡 '''import _thread import time #为线程定义一个函数 def a1(name,num): m=0 while m&lt;20: time.sleep(num) m+=1 print(name,m) try: _thread.start_new_t...
正则表达式——线程安全性
antaohui5955的博客
12-11 957
转载于:https://www.cnblogs.com/gaara0305/p/10103792.html
使用Java正则表达式分析处理日志
08-04
本篇将围绕“使用Java正则表达式分析处理日志”这一主题，探讨如何利用Java的正则表达式功能来提取、过滤和操作日志数据。 首先，我们需要理解正则表达式的基本概念。正则表达式（Regular Expression）是一种模式...
LogViewer:通用日志文件查看器（通过用户定义的正则表达式解析日志）
05-12
它可以通过提供正则表达式配置来解析日志文件。 支持多种日志格式，例如spring-boot，Android，iOS，Visual Studio等。 从理论上讲，只要您为其编写正则表达式，该工具就可以用于分析任何日志格式。 功能点 1.在...
正则表达式、JAVA线程
苦逼的程序猿☺
07-28 902
正则表达式定义指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。 因此，典型的调用顺序是 Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"
多线程 和 正则表达式
qq_42349617的博客
03-05 565
五、多线程 知识点总结 程序、进程与线程 • 程序Program： 是一段静态的代码（指令集合），它是应用程序执行的蓝本。 • 进程Process：指一种正在运行的程序，有自己的地址空间。当程序进入内存运行时，即变成一个进程，是运行中的程序，具有一定的独立功能，是系统资源分配和调度的一个独立单位。 • 线程Thread：进程内部的一个执行单元，它是程序中一个单一的顺序控制流程。线程又被称为轻量...
java 正则 线程安全_20-Java-正则表达式
weixin_35261385的博客
02-26 171
正则表达式(Regular Expression)概念：由实现定义好的特殊字符、及这些特殊字符的组合，组成一个“规则字符串”，这个“规则字符串”用来对字符串的这一种过滤逻辑。运用场景：检测字符串是否合法检索、替换符合规则的文本/字符串正则表达式的语法格式：“^$”(^代表开头，$代表结尾)正则表达式的组成：正则表达式由普通字符和特殊字符(元字符)组成比如：a-zA-Z0-9等特殊字符：预先定义好的...
15/7/27/正则表达式/进程线程/wait/notify
ForrestL的博客
07-28 426
正则表达式进程和线程正则表达式的简单应用1.正则表达式比较简单主要是看Pattern的API public static void main(String[] args) { // Pattern.compile功能是 将给定的正则表达式编译到模式中 // Pattern p = Pattern.compile("^\\w+@\\w+((.com)|(.cn)|(.net
学习c++新特性（五）正则表达式/并发并行
shihuangdeng898的博客
12-24 135
头文件 <regex>
java语法（二）正则表达式、线程并发、Juit单元测试、反射机制、注解、动态代理、XML解析、JVM
最新发布
芸兮的博客
05-15 1163
这就是使用Timer定时器的缺点所在，Timer本身是单线程的，处理多个任务按照顺序执行，存在延时与设置定时器的时间有出入。ScheduleExecutorService内部是线程池来处理定时任务，如果某个任务失败，那么这个线程会挂掉，不会影响其他线程的任务。相应的，当Blocked状态的线程获取到锁时，此线程就会进入到Runnable状态中参与CPUT资源的抢夺。同步方法的底层其实是隐式锁对象，只是锁的范围是整个方法代码，如果方法是实例方法，同步方法默认用。解决线程安全问题的方法有线程同步和线程通信。
Java正则与线程
weixin_45196232的博客
03-10 146
进程通常意义上讲为我们运行的一个应用程序进程由线程组成，一个进程至少包含一个线程进程脱离了线程就没有意义了。
4.多线程与正则表达式
W_SRB的专栏
09-25 1178
多线程的概念，如何在程序中创建多线程(Thread、Runnable)，线程安全问题，线程的同步，线程之间的通讯、死锁。Java图形用户介面编程(AWT、Swing)，Java的事件处理机制，Java Applet简介。 Java网络编程，网络通信底层协议TCP和UDP，以及其相应的Java实现：DatagramSocket，DatagramPacket，ServerSocket，Socket编
std::thread（线程）
热门推荐
傻月菇凉的博客
09-13 4万+
转自：https://www.cnblogs.com/whlook/p/6573659.html 创建线程 创建线程比较简单，C++提供头文件thread，使用std的thread实例化一个线程对象创建。 std::thread 在 #include 头文件中声明，因此使用 std::thread 时需要包含 #include 头文件。 #include&lt;iostream&gt...
Java正则表达式验证工具类
"正则表达式验证工具类 RegularValidate，包含对IP地址、邮箱和电话号码的验证方法，以及相关的正则表达式常量定义。" 正则表达式是一种强大的文本处理工具，常用于数据验证、搜索和替换等场景。在Java中，`java....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值