java初学者日志_线程

最新推荐文章于 2022-12-07 15:57:03 发布

星空辰梦

最新推荐文章于 2022-12-07 15:57:03 发布

阅读量243

点赞数

CC 4.0 BY-SA版权

分类专栏： java日记文章标签： java 多线程 thread

本文链接：https://blog.youkuaiyun.com/dream_start_/article/details/114329291

java日记专栏收录该内容

15 篇文章

订阅专栏

本文介绍了线程的四种创建方式及其生命周期，并详细探讨了线程同步机制，包括同步代码块、同步方法及Lock锁等多种解决线程安全问题的方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

线程的创建方式：4种
线程的同步：解决线程安全问题，有两种

线程的生命周期：
1：新建 ‘new‘
2：就绪调用start()，但不是就绪之后就会运行
3：运行获取CPU执行权之后开始运行，运行与就绪可以相互转化例如使用yield()
4：死亡执行完run()方法，调用线程的step()，出现异常(Exeption)都会使线程死亡
5：阻塞由运行态变为阻塞态，使用sleep()，join()，wait()，等待同步锁，会使线程变为阻塞状态。zus

创建多线程的第一种方式：Thread

/*多线程的创建，方式一：继承Thread
* 1.创建一个继承Thread类的子类
* 2.重写Thread类的run()方法
* 3.创建Thread类的自类的对象
* 4.通过此对象调用start()
* */

//例子：遍历100以内的所有偶数


//1.创建一个继承Thread类的子类
class MyThread extends Thread{
    //2重写Thread类的run()方法,
    // 将此线程所要执行的操作声明在run()方法中
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}
//3创建Thread类的自类的对象
public class ThreadTest {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        t1.start();
        System.out.println("Hello World");
    }

}

/*
* c创建两个线程，一个遍历100以内的偶数，另一个遍历100以内的奇数
* */

public class ThreadDemo {
    public static void main(String[] args) {
        MyThread1 t1=new MyThread1();
        MyThread2 t2=new MyThread2();
        t1.start();
        t2.start();
       /* //返回进程名
        String S=t1.getName();
        System.out.println(S);*/
    }
    
}
class MyThread2 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                System.out.println("我是偶数哒"+i);
            }
        }
    }
}

class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2!=0){
                System.out.println("我是奇数哒"+i);
            }
        }
    }
}

将一个线程添加到main()中，作为主线程

/*
* 测试Thread类的常用方法
* 1.static():启动当前的线程，调用run();
* 2.run()：通常需要重写
* 3.currentThread():静态方法，返回执行当前代码的线程
* 4.getName():获取当前线程的名字
* 5.setName():设置当前线程的名字
* 6.yield():释放当前cpu的执行权(下一个输出的可能不是该线程了)
* 7.join():当在线程b中调用线程a的join()时，线程b进入阻塞状态，直到线程a，执行完毕
* 8.sleep(long millitime):遇到该方法，应用场景：需要倒计时之类的桌面应用
* 9.isAlive()
*
*
*
* 线程优先级
* 1.
* MAX_PRIORITY:10
* MIN_PRIORITY:10
* NORM_PRIORITY:10
*
* 2.如何获取和设置当前线程的优先级
* getPriority();//获取当前线程的优先级
* setPriority(int p)//设置当前线程的优先级
*
* */
public class ThreadMethodTest {
    public static void main(String[] args) {
        test te=new test("a");
        //设置a线程的优先级
        te.setPriority(10);
        System.out.println("线程a的优先级为："+Thread.currentThread().getPriority());
        te.start();
        String str=te.getName();
        System.out.println(str);
        //te.setName("我是DIO哒");
        //给主线程命名
        Thread.currentThread().setName("b");
        //将主线程b的优先级设置最低
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        System.out.println("线程b的优先级为："+Thread.currentThread().getPriority());
        for (int i = 0; i <100 ; i++) {
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+ i );
            }
            /*if(i==20){
                try {
                    te.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }*/
            //System.out.println("a还活着吗？" +te.isAlive());
        }
    }
}
class test extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <100 ; i++) {
            if(i%2==0){
                /*try {
                    sleep(50);//沉睡，单位是ms
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }*/
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
            /*if(i%20==0){
                this.yield();
            }*/
        }
    }
    //通过构造器的方式给线程命名
    test(String name){
        super(name);
    }
}

买票

package com.duoxiancheng.Thread;
//创建三个窗口买票，总票数100
public class WindowTest {
    public static void main(String[] args) {
        Window t1=new Window();
        Window t2=new Window();
        Window t3=new Window();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }
}

class Window extends Thread{
    private static int ticket=100;
    @Override
    public void run() {
        while (true){
            if(ticket>0){
                System.out.println(getName()+"：买票，票号为："+ticket);
                ticket--;
            }else {
                break;
            };
        }
    }
}

创建多线程的第二种方：使用Runnable接口

/*多线程的创建，方式一：继承Thread
* 1.创建一个继承Thread类的子类
* 2.重写Thread类的run()方法
* 3.创建Thread类的自类的对象
* 4.通过此对象调用start()
* */

//例子：遍历100以内的所有偶数


//1.创建一个继承Thread类的子类
class MyThread extends Thread{
    //2重写Thread类的run()方法,
    // 将此线程所要执行的操作声明在run()方法中
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}
//3创建Thread类的自类的对象
public class ThreadTest {
    public static void main(String[] args) {
        MyThread t1=new MyThread();
        t1.start();
        System.out.println("Hello World");
    }

}

/*
* 创建三个窗口买票，总票数100,使用实现Runnable接口的方式
* */

class Window1 implements Runnable{
    private int ticket=100;//为什么不用static，因为t1,t2,t3调用的是同一个Window
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                ticket--;
            }else {
                break;
            }
        }
    }
}
public class Runnable2 {
    public static void main(String[] args) {
        Window1 w=new Window1();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();

    }
}

Thread 与Runnable方式的比较：
继承的方法有个缺陷，即单继承。
而实现Runnable接口，天然就能实现共享数据，不用将数据定义为static。

多线程经常要使用共享数据，所以选择Runnable
其次实现的方式没有类的单继承的局限性

创建多线程的第三种方式：Callable接口

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多项成方式强大

1.call()可以有返回值
2.call()可以抛出异常，被外边的操作捕获，获得异常信息
3.Callable支持泛型

import org.omg.PortableServer.THREAD_POLICY_ID;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/*
* 创建线程的方式三：实现Callable接口 --JDK5.0
* */

//1，创建一个实现Callable的实现类

class NumThread implements Callable{
 //2实现call方法，将此线程需要执行的操作声明在call方法中
    @Override
    public Object call() throws Exception {
        int sum=0;
        //遍历100以内的偶数，并返回偶数和
        for (int i = 0; i <=100 ; i++) {
            if (i%2==0){
                System.out.println(i);
                sum +=i;
            }
        }
        return sum;
    }
}

public class test_1 {
    public static void main(String[] args) {
//3.创建Callable接口实现类的对象
        NumThread numThread=new NumThread();
        //使用Future接口，FutureTask是Future唯一的实现类
//4.将此Callable接口实现类的对象作为参数传递到FutureTask构造器中，创建FutureTask的对象
        FutureTask f=new FutureTask(numThread);
//5.将FutureTaks的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
        new Thread(f).start();

        try {
//6.获取Callable中call方法的返回值
            //让get()返回值即为FutureTask构造器参数，Callable实现类重写的call()返回值
            Object sum= f.get();
            System.out.println(sum);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }
}

创建多线程的第四种方式：线程池
什么是线程池：提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中，避免频繁创建销毁，实现重复利用

优：
1.提高响应速度(减少了创建新线程的时间)
23降低资源消耗(用过的线程没有被销毁)
3.便于线程管理

import java.util.concurrent.*;

/*
*
* */

class NumberThread implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            if(i%2==0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

class NumberThread1 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i <20 ; i++) {
            if(i%2!=0){
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }

}

public class test_1 {
    public static void main(String[] args) {
        //1.提供指定线程数量的线程池
        ExecutorService serivce= Executors.newFixedThreadPool(10);
        ThreadPoolExecutor serivce1=(ThreadPoolExecutor) serivce;
        System.out.println(serivce.getClass());
        
        //设置线程池的属性
        serivce1.setCorePoolSize(15);
        serivce1.setKeepAliveTime(1000);//

        //2.执行指定的线程操作，需要提供实现Runnable接口或Callable接口实现类的对象
        serivce.execute(new NumberThread());//适用于Runnable
        serivce.execute(new NumberThread1());
        /*serivce.submit(new NumberThread1());//适合使用于Callable
        FutureTask futureTask=new FutureTask();*/
        
        //3.关闭连接池
        serivce.shutdown();
    }
}

线程安全问题：
1：买票过程中出现了重票，错票问题
2：出现的原因：线程在执行过程中，尚未操作完成时，其他进程也参与进来，发生错误
3：解决方法：当一个线程在操作ticket的时候，其他线程不能参与进来，直到线程操作完成。

在java中通过同步机制来解决安全问题
方式一：同步代码块
(1).Runnable&同步代码块

synchronized(同步监视器){
//需要被同步的代码
//说明：操作共享数据的代码，即为需要被同步的代码，对于共享数据不能包含代码多了，也不能少了
//共享数据：多个线程共同操作的变量。例如：ticket就是共享数据
//同步监视器：俗称锁，任何一个类的对象都可以充当锁
//要求：多个线程必须共用同一个同步监视器
}

class Window1 implements Runnable{
    private int ticket=100;//为什么不用static，因为t1,t2,t3调用的是同一个Window
    Object obj=new Object();
    @Override
    public void run() {

        while (true) {
            synchronized (obj) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class Runnable2 {
    public static void main(String[] args) {
        Window1 w=new Window1();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();

    }
}

(2)Thread&同步代码块

/*
* 使用同步代码块解决继承Thread类的安全问题
* 在继承Thread类的创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器
* */
public class Thread_daima {

    public static void main(String[] args) {
        Window5 t1=new Window5();
        Window5 t2=new Window5();
        Window5 t3=new Window5();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }
}
class Window5 extends Thread{
    private static int ticket=100;
    private static Object obj=new Object();
    @Override
    public void run() {
        while (true){
            //第一种方法
            //synchronized (obj){
                //第二种方法
                synchronized (Window5.class){
                if(ticket>0){
                    try {
                        sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(getName()+"：买票，票号为："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }

        }
    }
}

方式二：同步方法
1.同步方法仍然涉及到同步监视器，只是不需要显示的声明
2.非静态的同步方法，同步监视器是this,静态的同步方法，同步监视器是当前类本身

(1).Runnable&同步方法

public class Runnable_fangfa {
    public static void main(String[] args) {
        Window4 w=new Window4();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t3.start();

    }
}

class Window4 implements Runnable {
    private int ticket = 100;//为什么不用static，因为t1,t2,t3调用的是同一个Window

    @Override
    public void run() {//如果把run()定义为synchronized，会将while()也包裹进来，这就相当于只有一个窗口在运行run()
        while (true) {
            show();
        }

    }
    private synchronized void show(){//将方法声明为synchronized，在本方法中同步监视器就是this
        if (ticket > 0) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ":买票，票号为：" + ticket);
            ticket--;
        }
    }

}

(2)Thread&同步方法

/*
* 使用同步方法处理继承Thread类的线程安全问题
* */
public class Thread_fangfa {

    public static void main(String[] args) {
        Window6 t1=new Window6();
        Window6 t2=new Window6();
        Window6 t3=new Window6();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

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

    }
}
class Window6 extends Thread{
    private static int ticket=100;

    @Override
    public void run() {
        while (true){
               show();
        }
    }
    private static synchronized void show(){//非静态方法可以调用静态方法，同步监视器：Window6.class
    //private synchronized void show(){//在这里使用synchronized，因为有三个同步监视器t1,t2,t3，会失败
        if(ticket>0){
            try {
                sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName()+"：买票，票号为："+ticket);
            ticket--;
        }
    }
}

方式三：Lock类实现Lock

/*
* 使用Lock锁--java5.0新增
* Lock本身是个接口，我们主要使用ReentrantLock子类
* */
import java.util.concurrent.locks.ReentrantLock;

class Window implements Runnable{
    private int ticket=500;
    //1.实例化ReentrantLock
    private ReentrantLock lock=new ReentrantLock();
    @Override
    public void run() {
        while (true){
            try{
                //调用锁定方法lock()
                lock.lock();
                if(ticket>0){
                    try {
                        Thread.sleep(10);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println(Thread.currentThread().getName()+"：买票，票号为："+ticket);
                    ticket--;
                }else {
                    break;
                }
            }finally {
                //调用解锁方法
                lock.unlock();
            }
        }
    }
}

public class test__lock {
    public static void main(String[] args) {
        Window w=new Window();
        Thread t1=new Thread(w);
        Thread t2=new Thread(w);
        Thread t3=new Thread(w);

        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");

        t1.start();
        t2.start();
        t3.start();
    }
}

synchronized和Lock的异同：
同：都是解决线程安全问题
异：
synchronized：只有在执行完相应的同步代码后，能自动的释放同步监视器
Lock：想要结束同步，必须手动调用unlock()，但可以随时调用

练习：

/*
两个储户分别向同一个账户中存3000元，每次1000，每次存完后打印账户余额

分析：
1，是否是多线程问题  是
2，是否有共享数据  有，账户余额
是否有线程安全问题  有
4.如何解决
 */

import java.util.concurrent.locks.ReentrantLock;

class Account {
    private double balance;

    public Account(double balance) {
        this.balance = balance;
    }
    ReentrantLock lock =new ReentrantLock();
    //存钱
    public void deposit(double amt){
        try{
            lock.lock();
            if (amt>0){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                balance +=amt;
                System.out.println(Thread.currentThread().getName()+"存钱成功，余额为："+balance);
            }
        }finally {
            lock.unlock();
        }

    }

}
class customer extends Thread{
    private Account acct;

    public customer(Account acct){
        this.acct=acct;
    }

    @Override
    public void run() {
        for (int i = 0; i <3 ; i++) {
            acct.deposit(1000);
        }
    }
}
public class test_1 {
    public static void main(String[] args) {
        Account acct=new Account(0);
        customer c1=new customer(acct);
        customer c2=new customer(acct);

        c1.setName("甲");
        c2.setName("乙");

        c1.start();
        c2.start();
    }
}

线程的通信：两个线程访问同一个共享数据，产生了交流，就叫做线程的通信

/*
* 线程通信的例子，使用两个线程交替打印
*wait()与notify()必须在同步代码块或同步方法中使用
*
* */
class Number implements Runnable{
    private int number=1;

    @Override
    public void run() {
        while (true){
            synchronized (Number.class/*this*/){
                //一旦执行notify，就会唤醒被wait的一个线程，如果有多个，就唤醒优先级高的
                Number.class.notify();
                //this.notify();
                System.out.println("我是"+Thread.currentThread().getName()+"我拿着钥匙");
            if(number<=100){
                System.out.println(Thread.currentThread().getName()+"打印了："+number);
                number++;
                //让调用wait()方法的线程进入阻塞状态，同时线程持有同步监视器就会被释放，这点与sleep不同
                try {
                    Number.class.wait();
                    //this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {
                break;
            }
        }
    }
    }
}
public class test_tx {
    public static void main(String[] args) {
        Number n=new Number();
        Thread t1=new Thread(n);
        Thread t2=new Thread(n);
        t1.setName("线程1");
        t2.setName("线程2");
        t1.start();
        t2.start();

    }
}

sleep()与wait()的异同
同：一旦执行，就会是当前进程陷入阻塞状态
异：
1.两个方法声明位置不同，Thread类中声明sleep()，Object()类中声明wait()
2.sleep()可以在任何场景中使用，wait()只能在同步代码块或同步方法中调用
3.如果两个方法都使用在同步代码块或同步方法中sleep()不会释放同步监视器，wait()会自动释放

生产者消费者问题：

/*
* 生产者/消费者问题
*
* */

class Clerk{
    private int productCount=0;
    //生产产品
    public  synchronized void produceProduct(){

        if(productCount<20){
            productCount++;
            System.out.println(Thread.currentThread().getName()+":开始生产第："+productCount+"个产品");
            notify();
        }else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    //消费产品
    public synchronized void consumProduct() {

        if(productCount>0){
            System.out.println(Thread.currentThread().getName()+"：开始消费第："+productCount+"个产品");
            productCount--;
            notify();
        }else {
            //等待
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
class Producer extends Thread{
    private Clerk clerk;

    public Producer(Clerk clerk) {
        this.clerk = clerk;
    }

    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始生产产品");
        while (true){
            try {
                sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.produceProduct();
        }
    }
}

class Consumer extends Thread{
    private Clerk clerk;

    public Consumer(Clerk clerk) {
        this.clerk = clerk;
    }

    public void run() {
        System.out.println(Thread.currentThread().getName()+":开始消费产品");
        while (true){
            try {
                sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            clerk.consumProduct();
        }
    }
}

public class test_sx {
    public static void main(String[] args) {
        Clerk clerk=new Clerk();
        Producer p1=new Producer(clerk);
        p1.setName("生产者");
        Consumer c1=new Consumer(clerk);
        c1.setName("消费者");
        p1.start();
        c1.start();
    }
}

知识整理：
方式一:同步代码块
*
*
synchronized(同步监视器){
*
//需要被同步的代码
*
*
*
说明: 1. 操作共享数据的代码，即为需要被同步的代码。–> 不能包含代码多了，也不能包含代码少
了。
2.共享数据:多个线程共同操作的变量。比如: ticket就是共享数据。
3.同步监视器，俗称:锁。任何一个类的对象，都可以充当锁。
*
要求:多个线程必须要共用同一把锁。
*
*补充:在实现Runnable接口创建多线程的方式中，我们可以考虑使用this充当同步监视器。
在继承Thread类创建多线程的方式中，慎用this充当同步监视器，考虑使用当前类充当同步监视器。
*方式二: 同步方法。
*
如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
*关于同步方法的总结:
*
1.同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。
*
2.非静态的同步方法，同步监视器是: this
静态的同步方法，同步监视器是:当前类本身

方式三: Lock锁— JDK5. e新增
*

1.面试题: synchronized 与Lock的异同?
相同:二者都可以解决线程安全问题

不同: synchronized机制在执行完相应的同步代码以后，自动的释放同步监视器
Lock需要手动的启动同步(Lock(), 同时结束同步也需要手动的实现(unlock() )

使用优先顺序：(性能)
Lock 同步代码块同步方法

3.利弊
同步的方式，解决了线程的安全问题。—好处

操作同步代码时，只能一个线程参与，其他线程等待。相当于是一个单线程的过程，效率低。

线程通信

1.线程通信涉及到的三个方法:

wait():一旦执行此方法，当前线程就进入阻塞状态，并释放同步监视器。
notify():- 旦执行此方法，就会唤醒被wait的-一个线程。如果有多个线程被wait，就唤醒优先级高的那个。
notifyAll():一旦执行此方法，就会唤醒所有被wait的线程。
2.说明:
1.wait(), notify(), notifyALL()三个方法必须使用在同步代码块或同步方法中。
2.wait(), notify(), notifyAll()三个方法的调用者必须是同步代码块或同步方法中的同步监视器。
否则，会出现IllegaLMonitorStateException异常
3.wait(), notify(), notifyAll()三个方法是定义在java. lang. object类中。
3.面试题:
面试题: sleep()和wait()的异同? .
1.相同点: 一旦执行方法，都可以使得当前的线程进入阻塞状态。
2.不同点: 1两个方法声明的位置不同: Thread类中声明sLeep() ，object类中声明wait()
2调用的要求不同: sleep() 可以在任何需要的场景下调用。wait()必须使用在同步代码块或
同步方法中
3关于是否释放同步监视器:如果两个方法都使用在同步代码块或同步方法中，sleep()不会释
放锁，wait()会释放锁。

释放锁的操作：
1.当前线程的同步方法，同步代码块执行结束
2.当前线程在同步方法，同步代码块中遇到break，return终止了代码块
3.当前线程在同步方法，同步代码块中出现了未处理的Error或Exception，导致异常结束
4.
当前线程在同步方法，同步代码块中执行了线程对象的wait()方法，当前线程暂停，并释放锁

不会释放锁的操作：
1.线程执行同步代码块或同步方法时，程序调用Thread.sleep()，Thread.yield()方法暂停当前线程的执行
2.线程执行同步代码块时，其他线程调用了该线程的suspend()方法，将该线程挂起，该线程不会释放锁

如何理解实现Callable接口的方式创建多线程比实现Runnable接口创建多线程的方式强大
call()可以返回值的
call()可以抛出异常，被外面的操作捕获，获取异常信息
Callable是支持泛型的