[Js-Java SE]线程同步（加锁）（synchronized，守护进程，死锁，计时器）

 1 /*
 2     t1和t2
 3 
 4     异步编程模型：t1线程执行t1的，t2线程执行t2的，两个线程之间谁也不等谁。
 5 
 6     同步编程模型：t1线程和t2线程执行，当t1线程必须等t2线程执行结束之后,t1线程才能执行，这是同步编程模型。
 7 
 8 
 9     什么时候要同步呢？为什么要引入线程同步呢？
10         1.为了数据的安全。尽管应用程序的使用率降低，但是为了保证数据是安全的，必须加入线程同步机制。
11         线程同步机制使程序变成了（等同）单线程。
12 
13         2.什么条件下要使用线程同步？
14             第一：必须是多线程环境
15             第二：多线程环境共享同一个数据.
16             第三：共享的数据涉及到修改操作。
17     
18     以下程序演示取款例子。以下程序不使用线程同步机制，多线程
19     同时对同一个账户进行取款操作，会出现什么问题？
20 */
21 public class ThreadTest12
22 {
23     public static void main(String[] args){
24         
25         //创建一个公共的账户
26         Account act = new Account("actno-001",5000.0);
27 
28         //创建线程对同一个账户取款
29         Thread t1 = new Thread(new Processor(act));
30         Thread t2 = new Thread(new Processor(act));
31 
32         t1.start();
33 
34         t2.start();
35     }
36 }
37 
38 //取款线程
39 class Processor implements Runnable
40 {
41     //账户
42     Account act;
43 
44     //Constructor
45     Processor(Account act){
46         this.act = act;
47     }
48 
49     public void run(){
50         act.withdraw(1000.0);
51         System.out.println("取款1000.0成功，余额：" + act.getBalance());
52     }
53 }
54 
55 //账户
56 class Account
57 {
58     private String actno;
59     private double balance;
60 
61     public Account(){}
62     public Account(String actno,double balance){
63         this.actno = actno;
64         this.balance = balance;
65     }
66 
67     //setter and getter
68     public void setActno(String actno){
69         this.actno = actno;
70     }
71 
72     public void setBalance(double balance){
73         this.balance = balance;
74     }
75 
76     public String getActno(){
77         return actno;
78     }
79 
80     public double getBalance(){
81         return balance;
82     }
83 
84     //对外提供一个取款的方法
85     public void withdraw(double money){ //对当前账户进行取款操作
86 
87         double after = balance - money;
88         
89         //延迟
90         try{Thread.sleep(1000);}catch(Exception e){}
91         
92 
93         //更新
94         this.setBalance(after);
95     }
96 }

// 以上程序输出结果
/*
---------- java ----------
取款1000.0成功，余额：4000.0
取款1000.0成功，余额：4000.0

Output completed (1 sec consumed) - Normal Termination
*/

由上面的结果可知在第一个线程更新余额之前，第二个线程访问了账户余额，才导致了上面的结果，利用Java的synchronized关键字，我们改进的程序如下：

 1 /*
 2     以下程序使用线程同步机制保证数据的安全。
 3 */
 4 public class ThreadTest13
 5 {
 6     public static void main(String[] args){
 7         
 8         //创建一个公共的账户
 9         Account act = new Account("actno-001",5000.0);
10 
11         //创建线程对同一个账户取款
12         Thread t1 = new Thread(new Processor(act));
13         Thread t2 = new Thread(new Processor(act));
14 
15         t1.start();
16 
17         t2.start();
18     }
19 }
20 
21 //取款线程
22 class Processor implements Runnable
23 {
24     //账户
25     Account act;
26 
27     //Constructor
28     Processor(Account act){
29         this.act = act;
30     }
31 
32     public void run(){
33         act.withdraw(1000.0);
34         System.out.println("取款1000.0成功，余额：" + act.getBalance());
35     }
36 }
37 
38 //账户
39 class Account
40 {
41     private String actno;
42     private double balance;
43 
44     public Account(){}
45     public Account(String actno,double balance){
46         this.actno = actno;
47         this.balance = balance;
48     }
49 
50     //setter and getter
51     public void setActno(String actno){
52         this.actno = actno;
53     }
54 
55     public void setBalance(double balance){
56         this.balance = balance;
57     }
58 
59     public String getActno(){
60         return actno;
61     }
62 
63     public double getBalance(){
64         return balance;
65     }
66 
67     //对外提供一个取款的方法
68     public void withdraw(double money){ //对当前账户进行取款操作
69         
70         //把需要同步的代码，放到同步语句块中.
71         /*
72             原理：t1线程和t2线程.
73             t1线程执行到此处，遇到了synchronized关键字，就会去找this的对象锁，
74             如果找到this对象锁，则进入同步语句块中执行程序。当同步语句块中的代码
75             执行结束之后，t1线程归还this的对象锁。
76 
77             在t1线程执行同步语句块的过程中，如果t2线程也过来执行以下代码，也遇到
78             synchronized关键字，所以也去找this的对象锁，但是该对象锁被t1线程持有，
79             只能在这等待this对象的归还。
80         */
81         synchronized(this){
82 
83             double after = balance - money;
84         
85             //延迟
86             try{Thread.sleep(1000);}catch(Exception e){}
87             
88 
89             //更新
90             this.setBalance(after);
91         }
92         
93     }
94 }

// 运行结果：
/*
---------- java ----------
取款1000.0成功，余额：4000.0
取款1000.0成功，余额：3000.0

Output completed (2 sec consumed) - Normal Termination
*/

sychronized修饰静态代码块或者静态方法，产生类锁，每个类共享一把锁

sychronized修饰非静态代码块或者成员方法，产生对象锁，每个对象共享一把锁

死锁

以下程序描述了死锁

 1 /*
 2     死锁
 3 */
 4 public class DeadLock
 5 {
 6     public static void main(String[] args){
 7 
 8         Object o1 = new Object();
 9         Object o2 = new Object();
10 
11         Thread t1 = new Thread(new T1(o1,o2));
12         Thread t2 = new Thread(new T2(o1,o2));
13 
14         t1.start();
15         t2.start();
16 
17     }
18 }
19 
20 class T1 implements Runnable
21 {
22     Object o1;
23     Object o2;
24 
25     T1(Object o1,Object o2){
26         this.o1 = o1;
27         this.o2 = o2;
28     }
29 
30     public void run(){
31         synchronized(o1){
32             try{Thread.sleep(1000);}catch(Exception e){}
33             synchronized(o2){
34             
35             }
36         }
37     }
38 }
39 
40 
41 class T2 implements Runnable
42 {
43     Object o1;
44     Object o2;
45 
46     T2(Object o1,Object o2){
47         this.o1 = o1;
48         this.o2 = o2;
49     }
50 
51     public void run(){
52         synchronized(o2){
53             try{Thread.sleep(1000);}catch(Exception e){}
54             synchronized(o1){
55             
56             }
57         }
58     }
59 }

以上程序将永远等待执行，相似的概念是“羊群效应”，“哲学家吃饭问题”

守护线程

从线程分类上可以分为：用户线程（以上讲的都是用户线程），另一个是守护线程。守护线程是这样的，所有的用户线程结束生命周期，守护线程才会结束生命周期，只要有一个用户线程存在，那么守护线程就不会结束，例如 java 中著名的垃圾回收器就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。

 1 /*
 2     守护线程.
 3 
 4     其他所有的用户线程结束，则守护线程退出！
 5     守护线程一般都是无限执行的.
 6 */
 7 public class ThreadTest19
 8 {
 9     public static void main(String[] args) throws Exception{
10         
11         Thread t1 = new Processor();
12 
13         t1.setName("t1");
14         
15         //将t1这个用户线程修改成守护线程.
16         t1.setDaemon(true);
17 
18         t1.start();
19         
20         //主线程
21         for(int i=0;i<10;i++){
22             System.out.println(Thread.currentThread().getName()+"-->"+i);
23             Thread.sleep(1000);
24         }
25     }
26 }
27 
28 class Processor extends Thread
29 {
30     public void run(){
31         int i = 0;
32         while(true){
33             
34             i++;
35 
36             System.out.println(Thread.currentThread().getName()+"-->"+i);
37 
38             try{Thread.sleep(500);}catch(Exception e){}
39             
40         }
41 
42     }
43 }

// 输出结果
/*
---------- java ----------
main-->0
t1-->1
t1-->2
main-->1
t1-->3
t1-->4
main-->2
t1-->5
t1-->6
main-->3
t1-->7
t1-->8
main-->4
t1-->9
t1-->10
main-->5
t1-->11
t1-->12
main-->6
t1-->13
t1-->14
main-->7
t1-->15
t1-->16
main-->8
t1-->17
t1-->18
main-->9
t1-->19
t1-->20

Output completed (10 sec consumed) - Normal Termination
*/

主线程输出结束之后 t 线程结束

 

定时器

 1 /*
 2     关于定时器的应用.
 3     作用：每隔一段固定的时间执行一段代码.
 4 */
 5 import java.text.*;
 6 import java.util.*;
 7 
 8 public class TimerTest01
 9 {
10     public static void main(String[] args) throws Exception{
11         
12         //1.创建定时器
13         Timer t = new Timer();
14 
15         //2.指定定时任务
16         t.schedule(
17                 new LogTimerTask(), 
18                 new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").parse("2012-08-03 17:37:00 000"), 
19                 1000*10);
20 
21     }
22 }
23 
24 //指定任务
25 class LogTimerTask extends TimerTask
26 {
27     public void run(){
28         System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()));
29     }
30 }

 

注意：java.lang.Object下有两个方法分别是notify和wait，是控制当前对象线程等待和继续的方法

 

从线程分类上可以分为：用户线程（以上讲的都是用户线程），另一个是守护线程。守护线栈 堆 方法区main{……..}run {………}t1 线程run{i=0..i<10}t2 线程run {i=0..i<10}Processors = 0s = 45Processors = 0s = 45动力节点 http://www.bjpowernode.com17程是这样的，所有的用户线程结束生命周期，守护线程才会结束生命周期，只要有一个用户线程存在，那么守护线程就不会结束，例如 java 中著名的垃圾回收器就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。

转载于:https://www.cnblogs.com/jiasq/p/8528193.html