线程和正则表达式

正则表达式

正则表达式通常用于判断语句中，用来检查某一字符串是否满足某一格式。

接下来用几个常用例子来说明正则表达式的具体用法。

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

运行结果：