TwentyThreeDay-java 线程的睡眠与终止，synchronized

本文主要是介绍TwentyThreeDay-java 线程的睡眠与终止，synchronized，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

1、关于线程sleep方法

static void sleep(long millis)

静态方法，参数毫秒，作用：当前线程进入休眠（进入阻塞状态）放弃占用的CPU时间片，让给其它线程使用

public static void main(String[] args) {
    //使主线程睡眠5s
   /* try {
        Thread.sleep(1000*5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println(Thread.currentThread().getName());//5s后输出 main
​
    */
    //每间隔一秒输出
    for (int i = 0; i < 10; i++) {
        System.out.println(Thread.currentThread().getName()+"-->"+i);
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

2、终止线程睡眠

实现在主线程休眠五秒后叫醒分支线程，使用interrupt()，原理是使分支线程的睡眠出现异常，捕捉异常后，执行run中后续程序。

//MyThread01分支线程类

class MyThread01 implements Runnable{
    /*
    重点：run()方法不可以抛出异常，只能try...catch，
    原因是因为Runnable中run方法没有抛出异常，重写的方法不能比接口中的方法抛出的异常多
     */
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"开始");//Thread-0开始
        try {
            Thread.sleep(1000*60*60*24);//休眠一天
        } catch (InterruptedException e) {
            System.out.println(e.getMessage());//sleep interrupted
        }
        System.out.println(Thread.currentThread().getName()+"结束");//Thread-0结束
    }
}

//主线程

public static void main(String[] args) {
    //封装线程
    Thread thread=new Thread(new MyThread01());
    //启动线程
    thread.start();
    //主线程工作5s后终止分支线程的睡眠
    try {
        Thread.sleep(1000*5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    //终止run的睡眠
    thread.interrupt();//原理是使分支线程的睡眠出现异常，捕捉异常后，执行run中后续程序
​
}

3、使用shop（）终止线程

已过时，原因暴力终止线程会造成数据丢失

把2中的代码thread.interrupt()换成下面这行代码

thread.stop();//这种暴力终止线程，会使数据可能丢失

4、线程安全问题

1>、什么时候数据在多线程并发的环境下会存在安全问题？

满足三个条件：1、多线程并发，2、有共享数据，3、共享数据有修改的行为

2>、怎样解决线程安全问题？

当多线程并发的情况下，有共享数据，并且会被修改，此时就会存在线程安全问题，解决方法：线程排队执行（不能并发）称为线程同步机制， 线程排队则会牺牲效率，但是要以安全为主

3>、同步编程模型与异步编程模型

异步：（多线程并发）各自执行各自的

同步：多线程排队，两线程之间发生等待关系

5、关键字synchronized

//银行账户类

public class Account {
    private String act;
    private double blance;
    Object obj=new Object();
​
    public Account(String act, double blance) {
        this.act = act;
        this.blance = blance;
    }
​
    public String getAct() {
        return act;
    }
​
    public void setAct(String act) {
        this.act = act;
    }
​
    public double getBlance() {
        return blance;
    }
​
    public void setBlance(double blance) {
        this.blance = blance;
    }
    public void WithDrowMoney(double money){
        /*
        关键字synchronized线程安全的，小括号里是线程的共享对象，在此程序中，共享对象是账户对象故用this，或者obj,因为obj每个线程都有且只有一个。
        当一个线程遇到这个关键字，则会在这里（锁池）寻找对象锁，这时会释放之前占有的CPU时间片，如果没找到就要等待里面的线程执行完毕，找到之后
        就会锁门，然后进入就绪状态继续抢夺CPU时间片，其他想要进来的线程（与此线程共享对象的，不共享对象的不需要排队）需要等待。
        synchronized的代码块越少效率越高
         */
        synchronized(this){
            //取之前的余额
            double beforeBlance=this.blance;
            //取之后的余额
            double afterBlance = beforeBlance-money;
            //修改余额
            this.setBlance(afterBlance);
        }
    }
}

当synchronized 在方法上：

public synchronized void WithDrowMoney(double money){}

缺点：

则对象锁只能是this，不灵活，整个方法体都需要同步，扩大了同步范围，导致效率低

优点：代码节俭了，如果共享的对象就是this且整个代码开都要同步则可以使用这种方式

//线程

public class ThreadTest extends Thread{
    private Account act;
    //利用构造方法来使多个线程共享一个对象
    public ThreadTest(Account act){
        this.act=act;
    }
    @Override
    public void run() {
        //取钱，假设取5000
        double money=5000;
        //取款
        act.WithDrowMoney(money);
        System.out.println(Thread.currentThread().getName()+"账户："+act.getAct()+"取走金额："+money+",余额："+act.getBlance());
    }
}

//测试类

public static void main(String[] args) {
    //创建账户对象
    Account act=new Account("act-001",10000);
    //两个线程共享一个账户对象
    Thread t1=new ThreadTest(act);
    Thread t2=new ThreadTest(act);
    //修改名字
    t1.setName("t1");
    t2.setName("t2");
    //线程启动
    t1.start();
    t2.start();
​
}

6、总结synchronized

三种写法：

第一种：同步代码块

synchronized(线程共享对象){同步代码块；}

第二种：在实例方法上使用，表示共享对象一定是this，并且同步代码块是一整个方法体

第三种：在静态方法上使用synchronized,表示类锁，类锁永远只有一把。

7、写死锁

代码：

//线程MyThread05

class MyThread05 extends Thread{
    Object o1;
    Object o2;
    public MyThread05(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        //先锁o1在锁o2
        synchronized (o1){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o2){
​
            }
        }
    }
}

//线程Mythread06

class  Mythread06 extends Thread{
    Object o1;
    Object o2;
    public Mythread06(Object o1, Object o2) {
        this.o1 = o1;
        this.o2 = o2;
    }
    public void run(){
        //先锁o2在锁o1
        synchronized (o2){
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o1){
​
            }
        }
    }
}

//主线程

public static void main(String[] args) {
    Object o1=new Object();
    Object o2=new Object();
    //两个线程共享o1,o2
    Thread t1=new MyThread05(o1,o2);
    Thread t2=new Mythread06(o1,o2);
​
    t1.start();
    t2.start();
​
}

8、在解决线程安全问题的时候

尽量不使用synchronized,它会使程序执行效率降低，用户体验不好

第一：尽量使用局部变量来替代实例变量和静态变量

第二：如果必须使用实例变量，那么可以考虑创建多个对象，这样内存就不会共享了

第三：如果不能使用局部变量，对象也不能创建多个，那么就可以选择synchronized了，线程同步机制

这篇关于TwentyThreeDay-java 线程的睡眠与终止，synchronized的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！