线程和正则表达式

正则表达式 前端之家
前端之家收集整理的这篇文章主要介绍了线程和正则表达式，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

正则表达式

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

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();
    }
}

运行结果：

原文链接：/regex/360118.html

猜你在找的正则表达式相关文章

常用正则表达式-手机号、身份证、邮箱
一、校验数字的表达式 1 数字：^[0-9]*$ 2 n位的数字：^d{n}$ 3 至少n位的数字：^d{n,}$ 4...
JS正则表达式详解
正则表达式非常有用，查找、匹配、处理字符串、替换和转换字符串，输入输出等。下面整理一...
组内正则培训记录
0. 注： 不同语言中的正则表达式实现都会有一些不同。下文中的代码示例除特别说明的外，都...
高级正则表达式技术（Python版）
 正则表达式是从信息中搜索特定的模式的一把瑞士军刀。它们是一个巨大的工具库，其中的...
史上最全最常用的正则表达式
一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,...
正则表达式工具
正则表达式初步
分享5个可视化的正则表达式编辑工具
　　正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编...
分享5个可视化的正则表达式编辑工具
正则表达式使用单个字符串来描述、匹配一系列符合某个句法规则的字符串。在很多文本编辑器...
[知识积累]--正则表达式记忆表
在工作中常常遇到正则表达式问题，有时候又会忘记这则的语法。 下面就分享一份正则表达式记...
算法设计模式多媒体技术正则表达式ElasticsearchFlinkHadoopIDE
受约束摘*day25Java常用类库置信lamda留存持续录入年后正则表达式303.17regularexpre匹多模适20130322基础理论pathmunge涵义reectok需要转义的特资源分享validationex简明魔法里弄形如源码实现完备actionscript