多线程基础

谁砍了我的二叉树

于 2021-07-31 20:45:00 发布

阅读量95

点赞数

分类专栏：我的JAVA笔记文章标签：多线程

本文链接：https://blog.csdn.net/weixin_46687179/article/details/119281180

版权

我的JAVA笔记专栏收录该内容

15 篇文章 1 订阅

订阅专栏

多线程

线程的创建
- Thread
- Runnable
线程的方法
线程的生命周期
线程互斥共享(synchronized)
线程死锁
释放锁

线程的创建

Thread

当一个类继承了Thread类，那么该类就可以当作一个线程来使用
Thread的run方法是实现了 Runnable 接口的run方法

public class Thread01 {
    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        cat.start();//如果此时用cat.run();那run()就是主线程调用的方法,并没有真正启动一个线程
        //启动线程会最终底层去执行Cat的run方法
        //说明:在主线程(main)启动一个子线程Thread-0,主线程不会阻塞,会继续执行,实现并发执行
        //子线程和主线程会交替执行
        for(int i = 1; i <= 50; i ++){
            System.out.println("我是主线程"+i+Thread.currentThread().getName());
            Thread.sleep(1000);
        }
    }
}
class Cat extends Thread {
    int num = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hello world"+(++num)+Thread.currentThread().getName());
            try {
                Thread.sleep(1000);         //让该线程休眠1秒钟:单位是毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(num==80)break;
        }
    }
}

Runnable

因为Java是单继承，所有一但B类继承了A类，那B类就不能继承Thread类了
解决办法: 可以继承Runnable接口创建线程
Thread实现了Runnable接口

public class Runnable01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        //dog.start();是不行的
        //创建Thread对象,把dog对象(实现了Runnable接口),放入了Thread.
        Thread thread = new Thread(dog);
        thread.start();
    }
}
class Dog implements Runnable{
    int num = 0;
    @Override
    public void run() {
        while (true) {
            System.out.println("hello world"+(++num)+" " + Thread.currentThread().getName());
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if(num==80)break;
        }
    }
}

线程的方法

setDaemon() 设置守护线程方法（子线程无线循环,主线程结束,此子线程自动消亡）经典守护线程垃圾回收机制
setName() 给线程设置一个名字
Thread.sleep(time) 使当前线程休眠time毫秒
join() 设置主线程阻塞方法，子线程调用这个方法，主线程会阻塞，等待子线程结束才会唤醒
Thread.yield() 使当前进程进入就绪状态，可能会被执行，也可能不会被执行，主要看cpu
setPriority()和getPriority()设置和获取线程的优先级
t.interrupt() 使t线程中断结束
更多详细

package Thread_;
public class ThreadMethod {
    public static void main(String[] args) throws InterruptedException {
        T1 t1 = new T1();
        T2 t2 = new T2();
        t2.setDaemon(true);
        t1.start();
        t2.start();
        t1.setName("t1");
        t2.setName("t2");
        for (int i = 0; i < 20; i++) {
            Thread.sleep(500);
            System.out.println("main  " + i);
            if (i == 4) {
                System.out.println("****t1****");//这也是主线程的,因为它是在t1.join()之前,所以它可以执行
                t1.join();  //如果某个主线程的子线程是守护线程,那它就不会受此条代码的影响,除非那个守护进程自己调用join
                //t2.join();//如果此时调用join方法,那t2就会一直执行下去
                /*
                在哪个线程里调用就相当于给那个线程休眠，直到其他线程结束才会执行这个线程。
                在此处如果在加一个t2.join();那t1和t2还是会交替执行,因为休眠的是主线程
                 */
                //Thread.yield();//让子线程先执行，但是如果cpu资源非常丰富，就不会让步，在资源很紧张时才会执行成功
            }
        }
    }
}
class T1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("" + Thread.currentThread().getName() + "  " + i);
        }
    }
}
class T2 extends Thread {
    @Override
    public void run() {
        while (true) {
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "是守护者");
        }
    }
}

线程的生命周期

新建( new )：新创建了一个线程对象。
可运行( runnable )：线程对象创建后，其他线程(比如 main 线程）调用了该对象的 start ()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取 cpu 的使用权。
运行( running )：可运行状态( runnable )的线程获得了 cpu 时间片（ timeslice ），执行程序代码。
阻塞( block )：阻塞状态是指线程因为某种原因放弃了 cpu 使用权，也即让出了 cpu timeslice ，暂时停止运行。直到线程进入可运行( runnable )状态，才有机会再次获得 cpu timeslice 转到运行( running )状态。阻塞的情况分三种：
① 等待阻塞：运行( running )的线程执行 o . wait ()方法， JVM 会把该线程放入等待队列( waitting queue )中。
②同步阻塞：运行( running )的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则 JVM 会把该线程放入锁池( lock pool )中。
③其他阻塞: 运行( running )的线程执行 Thread . sleep ( long ms )或 t . join ()方法，或者发出了 I / O 请求时， JVM 会把该线程置为阻塞状态。当 sleep ()状态超时、 join ()等待线程终止或者超时、或者 I / O 处理完毕时，线程重新转入可运行( runnable )状态。
死亡( dead )：线程 run ()、 main () 方法执行结束，或者因异常退出了 run ()方法，则该线程结束生命周期。死亡的线程不可再次复生。

线程互斥共享(synchronized)

静态方法同步锁(类对象锁)
非静态方法同步锁(this对象锁)

package Thread_;
/**
 * 三个窗口共售一百张票  如果不加锁的话，那样就会出现超卖现象，因为多个线程会同时访问这个对象
 */
public class SellTicket {
    public static void main(String[] args) {
        //静态方法同步锁
        SellTicket01 sellTicket1 = new SellTicket01();
        SellTicket01 sellTicket2 = new SellTicket01();
        SellTicket01 sellTicket3 = new SellTicket01();
        //不加静态方法同步锁会出现了超卖现象
        sellTicket1.start();
        sellTicket2.start();
        sellTicket3.start();
        
        /*非静态方法同步锁
        SellTicket02 sellTicket02 = new SellTicket02();
        Thread t1 = new Thread(sellTicket02);
        Thread t2 = new Thread(sellTicket02);
        Thread t3 = new Thread(sellTicket02);
        t1.start();
        t2.start();
        t3.start();
         */
    }
}
//同步方法(静态的)的锁为当前对象本身    也就是SellTicket01.class
//适合: 多个对象建立的多个线程
class SellTicket01 extends Thread {
    private static int num = 100;       //多个线程共享100
    public static boolean sell1() {
        synchronized (SellTicket01.class){
            if (num <= 0) {
                System.out.println("售票结束！！！");
                return true;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票");
            System.out.println("还剩余:" + (--num) + "张票");
            return false;
        }
    }
    @Override
    public void run() {
        while (true) {
            if(sell1())break;
        }
    }
}
/*
   加锁方式 这个锁在this对象上的(也就是访问这个方法的线程对象),也可以在其他对象上,前提是同一个对象,比如把下面第二种的this换成	    object也可以的
   第一种:public synchronized boolean sell(){}就是同步一个方法
   第二种:在代码块上写 synchronized ,同步代码块
   适合: 一个对象建立的多个线程
*/
class SellTicket02 implements Runnable {
    private int num = 100;       //多个线程共享100
    Object object = new Object();
    //同步方法
    public synchronized boolean sell() {
        if (num <= 0) {
            System.out.println("售票结束！！！");
            return true;
        }
        try {
            Thread.sleep(50);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票");
        System.out.println("还剩余:" + (--num) + "张票");
        return false;
    }
    //同步代码快
    public boolean sell1() {
        synchronized (/*object*/this){
            if (num <= 0) {
                System.out.println("售票结束！！！");
                return true;
            }
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("窗口 " + Thread.currentThread().getName() + "售出一张票");
            System.out.println("还剩余:" + (--num) + "张票");
            return false;
        }
    }
    @Override
    public void run() {
        while (true) {
            if (sell1()) break;
        }
    }
}

线程死锁

同一时刻A对象获得a锁，B对象获得b锁，但是A对象需要获得b锁才能继续下去，B兑现需要获得a锁才能继续下去，发生了线程死锁。

package Thread_;
public class DeadLock_ {
    public static void main(String[] args) {
        DeadLockTest A = new DeadLockTest(true);
        DeadLockTest B = new DeadLockTest(false);
        A.setName("A");
        B.setName("B");
        A.start();
        B.start();
    }
}
class DeadLockTest extends Thread{
    static Object o1 = new Object();
    static Object o2 = new Object();
    private boolean flag;
    public DeadLockTest(boolean t){
        this.flag = t;
    }
    /**
     * ①当flag = true时,对象A会获取o1对象的锁,然后尝试获取o2对象锁,如果得不到就会DeadLock
     * ②当flag = false时,对象B会获取o2对象的锁,然后尝试获取o1对象锁,如果得不到就会DeadLock
     * 运行结果
     *  B:我是o2o2
     *  A:我是o1o1
     * 发生DeadLock
     */
    @Override
    public void run() {
        if(flag){
            synchronized (o1){
                System.out.println(Thread.currentThread().getName()+":我是o1o1");
                synchronized (o2){
                    System.out.println(Thread.currentThread().getName()+":我是o1o2");
                }
            }
        }else {
            synchronized (o2){
                System.out.println(Thread.currentThread().getName()+":我是o2o2");
                synchronized (o1){
                    System.out.println(Thread.currentThread().getName()+":我是o2o1");
                }
            }
        }
    }
}

释放锁

当前进程同步方法，同步代码块执行结束或者遇到break或return
当前进程同步方法，同步代码块中出现了未处理的Error或Exception，导致异常结束
当前进程同步方法，同步代码块中执行了线程对象的wait()方法，当前线程暂停，并释放锁
使用Thread.sleep(),Thread.yield()方法不会释放锁，只是暂停当前线程的执行

谁砍了我的二叉树

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
多线程基础

多线程线程的创建ThreadRunnable线程的方法线程的生命周期线程的创建Thread当一个类继承了Thread类，那么该类就可以当作一个线程来使用Thread的run方法是实现了 Runnable 接口的run方法public class Thread01 { public static void main(String[] args) throws InterruptedException { Cat cat = new Cat(); cat.
复制链接

扫一扫

专栏目录