这篇文章则主要介绍java多线程中的线程优先级,线程同步等相关内容。
一.线程的属性
下面将介绍线程的各种属性,包括:线程的优先级,守护线程,线程组,未被捕获的异常的处理。
1.1线程的优先级
在默认情况下,一个线程会继承其父类线程的优先级。当调度器决定运行一个新的线程的时候,首先会选择高优先级的线程。可以用setPriority()设置线程的优先级,设置的值在MIN_PRIORITY(1)与MAX_PRIORITY(10)之间的任何值。其中NORM_PRIORITY被定义为5。一般使用NORM_PRIORITY。设置的值越大,优先级越高。
所谓线程优先级是对资源竞争的一个辨别依据,就是说当多个线程竞争资源时,具有较高优先级的线程会优先执行。当线程执行过程很短、逻辑不复杂,则不存在竞争问题,所以写demo会看不出优先级的作用。
1.2守护线程
java中线程分为两种类型:用户线程和守护线程,不设置的时候,默认为用户线程。
用户线程:Thread.setDaemon(false);
守护线程:Thread.setDaemon(true);
用户线程与守护线程的区别:主线程结束后,用户线程还没结束的时候,JVM会继续存活;主线程结束后,守护线程还没结束,JVM会结束。
Demo演示:
class DaemonThread extends Thread {
public void run() { //这个线程会一直执行
while(true){
try {
Thread.sleep(1000);
} catch (InterruptedException ex) {
}
System.out.println("hi,yyq!");//每隔一秒打印"hi,yyq!"
}
}
public static void main(String [] args) {
DaemonThread test = new DaemonThread();
//test.setDaemon(false); //设置为false,则为用户线程,当主线程运行结束后,用户线程还会执行。
test.setDaemon(true); //设置为true,则为守护线程,当主线程运行结束后,守护线程也会结束。
test.start();
System.out.println("isDaemon = " + test.isDaemon());
try {
Thread.sleep(5000);
} catch (Exception ex) {}
}
}
demo说明:DaemonThread是一个一直执行的线程,并且每隔一秒输出一次“hi,yyq!”这句话。main函数是让主线程休眠5s,5s后主线程结束,这时候DaemonThread如果是用户线程,则不会结束,一直打印"hi,yyq!",如果是守护线程,则会结束,不打印这句话。执行效果:
当为test.setDaemon(false):运行结果为:
isDaemon = false
hi,yyq!
hi,yyq!
hi,yyq!
hi,yyq!
hi,yyq!
hi,yyq!
hi,yyq!
hi,yyq!
hi,yyq!.......
当为test.setDaemon(true):运行结果为:
isDaemon = false
hi,yyq!
hi,yyq!
hi,yyq!
hi,yyq!
hi,yyq!
二.线程的同步
在多线程应用中,常常需要两个或两个以上线程对同一数据的存取,由于各线程的访问数据的顺序不同,结果可能大相径庭。所以,这时候就需要用到线程同步。
举例,我们每个人都有银行账户Account,Account可以存钱,取钱,查询剩余钱数。不过,为了演示效果,我们可以分十次存钱,十次取钱。
//定义一个账户类Account
class Account{
int money = 0;//账户没有钱
//add方法是存钱,每次存10元,共十次
public void add() {
for(int i = 0; i < 10; i++) {
money += 10;
System.out.println(Thread.currentThread().getName() + ": " + account.getMoney());
}
}
//sub方法是取钱,每次取10元,共十次
public void sub() {
for(int i = 0; i < 10; i++) {
money -= 10;
System.out.println(Thread.currentThread().getName() + ": " + account.getMoney());
}
}
//获取钱的总数
public int getMoney() {
return money;
}
}
然后,我们有两个线程,一个线程做存钱操作,一个线程做取钱操作。
` //线程A是存钱
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
account.add();//存钱操作
}
},"ThreadA");
//线程B是取钱
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
account.sub();//取钱操作
}
},"ThreadB");
然后,运行。得到的结果是:
ThreadA: 10
ThreadA: 20
ThreadA: 30
ThreadA: 40
ThreadB: 30
ThreadA: 40
ThreadB: 30
ThreadA: 40
ThreadB: 30
ThreadA: 40
ThreadB: 30
ThreadA: 40
ThreadB: 30
ThreadA: 40
ThreadB: 30
ThreadA: 40
ThreadB: 30
ThreadB: 20
ThreadB: 10
ThreadB: 0
可以发现,一旦存取线程开启,就不受控,执行顺序随机。可以我们期望的效果是,存钱一次执行完毕,最后剩余金额应该是100。取钱也是同理。怎么解决这个问题?
可以用java关键字synchronized,是一种同步锁。它修饰的对象有以下几种:
1. 修饰一个代码块,被修饰的代码块称为同步语句块,其作用的范围是大括号{}括起来的代码,作用的对象是调用这个代码块的对象;
2. 修饰一个方法,被修饰的方法称为同步方法,其作用的范围是整个方法,作用的对象是调用这个方法的对象;
3. 修改一个静态的方法,其作用的范围是整个静态方法,作用的对象是这个类的所有对象;
4. 修改一个类,其作用的范围是synchronized后面括号括起来的部分,作用主的对象是这个类的所有对象。
在这个例子中,我们可以用synchronized修饰Account账户中的add( ), sub( )。表示已经锁住这个方法所持有的引用,即account这个对象现在只能被单个线程调用,所以当执行ThreadA.start()之后,ThreadB一直处于阻塞状态,只有当ThreadA中的synchronized add( )执行完毕,才会调用 synchronized sub( )方法。
改正后,用到线程同步的完整代码如下:
public class WithoutSyn {
//定义一个账户类Account
class Account{
int money = 0;//账户没有钱
//add方法是存钱,每次存10元,共十次
public synchronized void add() {
for(int i = 0; i < 10; i++) {
money += 10;
System.out.println(Thread.currentThread().getName() + ": " + account.getMoney());
}
}
//sub方法是取钱,每次取10元,共十次
public synchronized void sub() {
for(int i = 0; i < 10; i++) {
money -= 10;
System.out.println(Thread.currentThread().getName() + ": " + account.getMoney());
}
}
//获取钱的总数
public int getMoney() {
return money;
}
}
Account account = new Account();
//线程A是存钱
Thread threadA = new Thread(new Runnable() {
@Override
public void run() {
account.add();//存钱操作
}
},"ThreadA");
//线程B是取钱
Thread threadB = new Thread(new Runnable() {
@Override
public void run() {
account.sub();//取钱操作
}
},"ThreadB");
public static void main(String[] args) {
WithoutSyn withoutSyn = new WithoutSyn();
withoutSyn.threadA.start();
withoutSyn.threadB.start();
}
}
执行结果为:
ThreadA: 10
ThreadA: 20
ThreadA: 30
ThreadA: 40
ThreadA: 50
ThreadA: 60
ThreadA: 70
ThreadA: 80
ThreadA: 90
ThreadA: 100
ThreadB: 90
ThreadB: 80
ThreadB: 70
ThreadB: 60
ThreadB: 50
ThreadB: 40
ThreadB: 30
ThreadB: 20
ThreadB: 10
ThreadB: 0
可以看到,确实是一次执行完存钱操作,也一次执行完取钱操作。