Java基础回顾之——多线程2

在上一篇中，介绍了java中多线程的基础知识

这篇文章则主要介绍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
可以看到，确实是一次执行完存钱操作，也一次执行完取钱操作。