创建线程的三种方式
继承Thread类,重写run方法
Thread类中有字段target为Runnable接口的实例,run方法不经过重写会默认执行target的run方法。
重写后调用该类的start方法即可交给JVM创建一个新的线程执行run中的指令
这种方法的优点是写着简单
缺点是Java没有多继承,继承Thread就不能继承其他类,灵活性低
实现Runnable接口
Runnable是一个函数式接口,只有一个抽象方法run
实现Runnable接口和run方法后可以创建一个Thread的实例,传入一个Runnable接口实例赋给Thread中的target字段,以此来调用其start方法来创建新线程。具体的操作可以用接口回调或者lambda表达式来实现
接口回调
class exam1 implements Runnable{
private void doSomething() {
}
@Override
public void run() {
doSomething();
}
static {
Thread thread=new Thread(new exam1());
}
}
Lambda
因为Runnable是一个函数式接口(@Functionalnterface),可以通过Java8中新增加的Lambda来实现
Thread thread=new Thread(()-> doSomething());
实现Callable接口
观察Callable接口和Runnable接口的不同,call方法可以有返回值,并且可以抛出错误,是功能更完善的Runnable
使用方法,借助FutrueTask(实现了Runnable接口)来使用,FutrueTask中的run方法会执行传入Callable实例的call方法
FutureTask futureTask=new FutureTask(()->{
while(true){
System.out.println("thread a");
}
});
Thread thread=new Thread(futureTask);
thread.start();
实质上还是执行的run方法,下面是FutureTask源码
FutureTask状态转换
NEW:表示一个新的任务,初始状态。
COMPLETING:当任务被设置结果时,处于COMPLETING状态,这是一个中间状态。
NORMAL:表示任务正常结束。
EXCEPTIONAL:表示任务因异常而结束。
CANCELLED:任务还未执行之前就调用了cancel(true)方法,任务处于CANCELLED。
INTERRUPTING:当任务调用cancel(true)中断程序时,任务处于INTERRUPTING状态,这是一个中间状态。
INTERRUPTED:任务调用cancel(true)中断程序时会调用interrupt()方法中断线程运行,任务状态由INTERRUPTING转变为INTERRUPTED。
脏读
类似于数据库中的脏读问题,是由于在线程A中读取到了线程B尚未提交的数据,随后B回滚事务,导致线程A读取到了根本不存在的数据。
demo:
Data data=new Data("name",100);
Thread thread=new Thread(()->{
//记录旧的数据
int oldData=data.data;
String oldString= data.name;
data.name="dirtyData";
try {
Thread.currentThread().sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
data.data=0;
//判定是否需要回滚
if(data.data==0) {
//回滚
data.data=oldData;
data.name=oldString;
}
});
thread.start();
Thread.currentThread().sleep(100);
System.out.println("name== "+data.name);
System.out.println("data== "+data.data);
不可重复读
不可重复读是指一个线程前后两次读取的数据不一致
死锁
类似于数据库中的死锁,各个线程之间的等待关系形成了一个环,导致这个进程陷入空等
demo:
//注意s1和s2必须不一样,否则jvm会自动将s1与s2视作同一实例
String s1="s1";
String s2="s2";
new Thread(()->{
synchronized (s1){
try {
System.out.println("锁s1并且暂停");
Thread.currentThread().sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s2){
}
}
System.out.println("Thread a over");
}).start();
synchronized (s2){
try {
System.out.println("锁s2并且暂停");
Thread.currentThread().sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
synchronized (s1){
}
}
System.out.println("Thread b over");
锁--synchronized和Lock的使用
synchronized
这个关键字的作用是给实例方法,静态方法,代码块(this|object)加锁,使得他们变成线程安全的
对于普通同步方法,锁是当前实例对象。
对于静态同步方法,锁是当前类的Class对象。
对于同步方法块,锁是Synchonized括号里配置的对象。
提一句synchronized的锁信息会存储在内存中对象存储区域中对象头中,更具体的说是存储在标记字段
Lock
JDK1.5之后引入了新的Lock锁,目的是提升锁的灵活性
Lock接口中有五个方法(tryLock重载一次)作用分别如下
//获取锁,不会自动释放锁,需要手动释放,使用的时候可以用try catch结构在finally代码块里释放锁
void lock();
//有返回值的获取锁,如果成功则返回true,这个方法可以避免死锁
boolean tryLock();
//第一个参数是时间,第二个是时间单位,TimeUnit枚举类型
boolean tryLock(long time, TimeUnit unit) throws InterruptedException;
//释放锁
void unlock();
//相当于可以响应中断的trylock()方法
void lockInterruptibly() throws InterruptedException;
Condition newCondition();
Lock在JDK中的实现类只有ReentrantLock一个,意思是可重入锁,也就是一个线程获取锁以后可以再次获取锁,不会出现死锁的情况
Lock避免死锁
同样是上面死锁的例子,改写使其无法死锁
public static void main(String[] args) throws InterruptedException {
Lock lock1 = new ReentrantLock();
Lock lock2 = new ReentrantLock();
doSomething(lock1,lock2);
doSomething(lock2,lock1);
}
public static void doSomething(Lock lock1,Lock lock2){
new Thread(()->{
while(true) {
try {
if(lock1.tryLock(1,TimeUnit.SECONDS)){
Thread.sleep(50);
if(lock2.tryLock(1,TimeUnit.SECONDS)){
System.out.println("success");
break;
}else{
lock1.unlock();
continue;
}
}else{
continue;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
lock1.unlock();
lock2.unlock();
}).start();
}