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

/*
    t1和t2

    异步编程模型：t1线程执行t1的，t2线程执行t2的，两个线程之间谁也不等谁。

    同步编程模型：t1线程和t2线程执行，当t1线程必须等t2线程执行结束之后,t1线程才能执行，这是同步编程模型。


    什么时候要同步呢？为什么要引入线程同步呢？
        1.为了数据的安全。尽管应用程序的使用率降低，但是为了保证数据是安全的，必须加入线程同步机制。
        线程同步机制使程序变成了（等同）单线程。

        2.什么条件下要使用线程同步？
            第一：必须是多线程环境
            第二：多线程环境共享同一个数据.
            第三：共享的数据涉及到修改操作。
    
    以下程序演示取款例子。以下程序不使用线程同步机制，多线程
    同时对同一个账户进行取款操作，会出现什么问题？
*/
public class ThreadTest12
{
    public static void main(String[] args){
        
        //创建一个公共的账户
        Account act = new Account("actno-001",5000.0);

        //创建线程对同一个账户取款
        Thread t1 = new Thread(new Processor(act));
        Thread t2 = new Thread(new Processor(act));

        t1.start();

        t2.start();
    }
}

//取款线程
class Processor implements Runnable
{
    //账户
    Account act;

    //Constructor
    Processor(Account act){
        this.act = act;
    }

    public void run(){
        act.withdraw(1000.0);
        System.out.println("取款1000.0成功，余额：" + act.getBalance());
    }
}

//账户
class Account
{
    private String actno;
    private double balance;

    public Account(){}
    public Account(String actno,double balance){
        this.actno = actno;
        this.balance = balance;
    }

    //setter and getter
    public void setActno(String actno){
        this.actno = actno;
    }

    public void setBalance(double balance){
        this.balance = balance;
    }

    public String getActno(){
        return actno;
    }

    public double getBalance(){
        return balance;
    }

    //对外提供一个取款的方法
    public void withdraw(double money){ //对当前账户进行取款操作

        double after = balance - money;
        
        //延迟
        try{Thread.sleep(1000);}catch(Exception e){}
        

        //更新
        this.setBalance(after);
    }
}

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

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

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

/*
    以下程序使用线程同步机制保证数据的安全。
*/
public class ThreadTest13
{
    public static void main(String[] args){
        
        //创建一个公共的账户
        Account act = new Account("actno-001",5000.0);

        //创建线程对同一个账户取款
        Thread t1 = new Thread(new Processor(act));
        Thread t2 = new Thread(new Processor(act));

        t1.start();

        t2.start();
    }
}

//取款线程
class Processor implements Runnable
{
    //账户
    Account act;

    //Constructor
    Processor(Account act){
        this.act = act;
    }

    public void run(){
        act.withdraw(1000.0);
        System.out.println("取款1000.0成功，余额：" + act.getBalance());
    }
}

//账户
class Account
{
    private String actno;
    private double balance;

    public Account(){}
    public Account(String actno,double balance){
        this.actno = actno;
        this.balance = balance;
    }

    //setter and getter
    public void setActno(String actno){
        this.actno = actno;
    }

    public void setBalance(double balance){
        this.balance = balance;
    }

    public String getActno(){
        return actno;
    }

    public double getBalance(){
        return balance;
    }

    //对外提供一个取款的方法
    public void withdraw(double money){ //对当前账户进行取款操作
        
        //把需要同步的代码，放到同步语句块中.
        /*
            原理：t1线程和t2线程.
            t1线程执行到此处，遇到了synchronized关键字，就会去找this的对象锁，
            如果找到this对象锁，则进入同步语句块中执行程序。当同步语句块中的代码
            执行结束之后，t1线程归还this的对象锁。

            在t1线程执行同步语句块的过程中，如果t2线程也过来执行以下代码，也遇到
            synchronized关键字，所以也去找this的对象锁，但是该对象锁被t1线程持有，
            只能在这等待this对象的归还。
        */
        synchronized(this){

            double after = balance - money;
        
            //延迟
            try{Thread.sleep(1000);}catch(Exception e){}
            

            //更新
            this.setBalance(after);
        }
        
    }
}

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

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

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

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

死锁

以下程序描述了死锁

/*
    死锁
*/
public class DeadLock
{
    public static void main(String[] args){

        Object o1 = new Object();
        Object o2 = new Object();

        Thread t1 = new Thread(new T1(o1,o2));
        Thread t2 = new Thread(new T2(o1,o2));

        t1.start();
        t2.start();

    }
}

class T1 implements Runnable
{
    Object o1;
    Object o2;

    T1(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    public void run(){
        synchronized(o1){
            try{Thread.sleep(1000);}catch(Exception e){}
            synchronized(o2){
            
            }
        }
    }
}


class T2 implements Runnable
{
    Object o1;
    Object o2;

    T2(Object o1,Object o2){
        this.o1 = o1;
        this.o2 = o2;
    }

    public void run(){
        synchronized(o2){
            try{Thread.sleep(1000);}catch(Exception e){}
            synchronized(o1){
            
            }
        }
    }
}

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

守护线程

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

/*
    守护线程.

    其他所有的用户线程结束，则守护线程退出！
    守护线程一般都是无限执行的.
*/
public class ThreadTest19
{
    public static void main(String[] args) throws Exception{
        
        Thread t1 = new Processor();

        t1.setName("t1");
        
        //将t1这个用户线程修改成守护线程.
        t1.setDaemon(true);

        t1.start();
        
        //主线程
        for(int i=0;i<10;i++){
            System.out.println(Thread.currentThread().getName()+"-->"+i);
            Thread.sleep(1000);
        }
    }
}

class Processor extends Thread
{
    public void run(){
        int i = 0;
        while(true){
            
            i++;

            System.out.println(Thread.currentThread().getName()+"-->"+i);

            try{Thread.sleep(500);}catch(Exception e){}
            
        }

    }
}

// 输出结果
/*
---------- 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 线程结束

定时器

/*
    关于定时器的应用.
    作用：每隔一段固定的时间执行一段代码.
*/
import java.text.*;
import java.util.*;

public class TimerTest01
{
    public static void main(String[] args) throws Exception{
        
        //1.创建定时器
        Timer t = new Timer();

        //2.指定定时任务
        t.schedule(
                new LogTimerTask(), 
                new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").parse("2012-08-03 17:37:00 000"), 
                1000*10);

    }
}

//指定任务
class LogTimerTask extends TimerTask
{
    public void run(){
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS").format(new Date()));
    }
}

注意：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 中著名的垃圾回收器就是一个守护线程，只有应用程序中所有的线程结束，它才会结束。