Thread多线程

于 2020-01-06 17:15:18 发布
阅读量76 收藏
点赞数
分类专栏： Java-basic 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zezea/article/details/103843452
版权

Thread多线程

在学习多线程之前，需要先了解如下要点：
并发：指两个或多个事件在同一 时间段 内发生。
并行：指两个或多个事件在同一 时刻 发生。
程序：在 硬盘中（ROM），关机后不会消失。
进程：是指在 内存中运行 的应用程序。在 内存中（RAM），关机后会消失。进程是程序的执行单元。
线程：线程是 进程的一个执行单元 。一个进程中至少有一个线程 。当一个程序执行一个功能时，就会开启一条应用程序到CPU的执行路径（线程），CPU就可以通过这个路径执行功能。
线程调度的两种方式：分时调度 、抢占式调度
分时调度：所有线程轮流使用cup，平均分配 占用时间。
抢占式调度：先让 优先级高的 线程使用CPU，如果优先级相同，则随机一个线程，java使用的是抢占式调度。

当我们在执行main方法时，就执行了主（main）方法的线程，这时我们运行的是单线程程序。而创建多线程程序有两种方式：
1.创建Thread类的子类
2.实现Runable接口

1.方法1注意事项：
java.lang.Thread:是描述线程的类，我们想要实现多线程程序，就必须继承Thread类
Thread类中的void start方法使线程开始执行，java虚拟机调用该线程的run方法
结果是，当前线程（main线程）与另一个线程（创建的新线程，执行run方法）两个线程并发的运行。
多次启动一个线程是非法的，特别是当线程已经结束执行后，不能再重新启动。
java属于抢占式调度，哪个线程的优先级高，就先执行哪个，优先级一样，随机选择一个执行。

//1.创建类继承Thread
public class MyThread extends Thread {
    @Override//2.重写run方法，内部为要实现的代码
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run: " +i);
        }
    }
}

//main
public static void main(String[] args) {
        //3.新建线程对象
        MyThread thread = new MyThread();
        //4.执行对象start方法
        thread.start();
        for (int i = 0; i < 20; i++) {
            System.out.println("main:" + i);
        }
        /*结果：两线程抢占式执行
        run: 0
        run: 1
        main:0
        run: 2
        main:1
        run: 3
        main:2
        run: 4
        main:3
        run: 5
        main:4
        run: 6
        main:5
        run: 7
        main:6
        run: 8
        main:7
        run: 9
        main:8
        run: 10
        main:9
        run: 11
        main:10
        main:11
        main:12
        main:13
        run: 12
        main:14
        run: 13
        main:15
        run: 14
        main:16
        run: 15
        main:17
        run: 16
        main:18
        run: 17
        main:19
        run: 18
        run: 19*/
    }

2.实现Runable接口的好处：1.避免了单继承的局限性。实现类还可以继承其他类2.增强了程序的扩展性，降低了程序的耦合性。

public class MyThreadImpl implements Runnable {
    @Override
    public void run() {
        for (int i = 60; i > 0; i--) {
            System.out.println(i);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public static void main(String[] args) {
        MyThreadImpl myThread = new MyThreadImpl();
        Thread thread = new Thread(myThread);
        thread.start();
    }

3.匿名内部类实现多线程

public static void main(String[] args) {
        //1.
        new Thread("匿名子类"){
            @Override
            public void run() {
                for (int i = 0; i < 60; i++) {
                    System.out.println("a"+"b"+i);
                }
            }
        }.start();
        //2.
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 60; i++) {
                    System.out.println(i);
                }
            }
        },"匿名接口实现类").start();
    }

线程的安全机制：当多个线程抢占CPU执行时，如果访问公共资源，就有可能引起线程安全问题。为解决这一问题，需要使用线程同步机制：
1.解决线程安全的第一种方式：使用同步代码块synchronized()
格式：
synchronized(锁对象){
可能会出现安全问题的代码（访问了共享数据的代码）
}
注意：
1.同步代码块中的对象，可以是任意对象
2.必须保证多个线程使用的锁对象是同一个
3.锁对象作用是：把同步代码块锁住，只让一个线程在同步代码块中执行

public class RunableImpl implements Runnable {
    private int ticket = 100;
    //创建一个锁对象，不能在run方法内，不然当运行run方法时会创建多个Object对象，不唯一。
    Object obj = new Object();
    @Override
    public void run() {
        while(true){
        //Object obj = new Object();错误
            synchronized (obj){
                if(ticket > 0){
                    System.out.println("正在买票" + ticket);
                    ticket--;
                }
            }

        }
    }
}

public static void main(String[] args) {
        RunableImpl runable = new RunableImpl();
        new Thread(runable).start();
        new Thread(runable).start();
        new Thread(runable).start();
    }

2.解决线程安全的第二种方式：使用同步方法
public synchronized void method()

private int ticket = 100;

    @Override
    public void run() {
        while(true){
            method();
        }
    }
    //方法的锁对象是this
    public synchronized void method(){
        if(ticket > 0){
            System.out.println("正在买票" + ticket);
            ticket--;
        }
    }

public static void main(String[] args) {
        RunableImpl runable = new RunableImpl();
        new Thread(runable).start();
        new Thread(runable).start();
        new Thread(runable).start();
    }

3.解决线程安全的第三种方式：使用静态同步方法
public static synchronized void method()

public class RunableImpl implements Runnable {
    private static int ticket = 100;

    @Override
    public void run() {
        while(true){
            method();
        }
    }
    //静态方法的锁对象是本类的class属性-->class文件对象（反射）
    public static synchronized void method(){
        if(ticket > 0){
            System.out.println("正在买票" + ticket);
            ticket--;
        }
    }

    public static void main(String[] args) {
        RunableImpl runable = new RunableImpl();
        new Thread(runable).start();
        new Thread(runable).start();
        new Thread(runable).start();
    }

4.解决线程安全的第四种方式：使用Lock锁
Lock接口中的方法：
void lock();获取锁
void unlock();释放锁
其实现类ReentrantLock implement Lock

public class RunableImpl implements Runnable {
    private static int ticket = 100;
    Lock l = new ReentrantLock();//新建锁对象
    @Override
    public void run() {
        while(true){
            l.lock();

            try{
                if(ticket > 0){
                    System.out.println("正在买票" + ticket);
                    ticket--;
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                l.unlock();//最终都会解除锁定
            }

        }
    }
}

线程的六个状态：NEW-新建（就绪）状态、blocked-阻塞状态、runnable-运行状态、timed_waiting-休眠状态、waiting-等待状态、terminated-死亡状态。
在这里插入图片描述
线程的状态转换方法：
1.进入timed_waiting-休眠状态。
sleep(long millis)
wait(long millis)
休眠结束后会进入运行状态或阻塞状态。

//sleep
public static void main(String[] args) {
        for (int i = 0; i < 60; i++) {
            System.out.println(i);
            try {
                Thread.sleep(1000);//休眠
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

//wait()的特殊之处在于，休眠中可以被唤醒（notify）。
public static void main(String[] args) {
        Object obj = new Object();
        new Thread("顾客1"){
            @Override
            public void run() {
                synchronized (obj){
                    System.out.println("顾客1告诉老板要什么包子");
                    try {
                        obj.wait(60000);//计时等待，等待超过时间，自动醒来，进入Runnable/Blocked状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("顾客1吃包子");
                }
            }
        }.start();
 }

2.进入waiting-等待状态
wait()
只有被唤醒才能进入运行状态或阻塞状态。

//wait()
public static void main(String[] args) {
        Object obj = new Object();
        new Thread("顾客"){
            @Override
            public void run() {
                synchronized (obj){
                    System.out.println("告诉老板要什么包子");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("吃包子");
                }
            }
        }.start();
}

3.从等待状态中进入运行状态或阻塞状态。
notify()
notifyAll()
只能唤醒使用了wait方法的线程。

//notify()
public static void main(String[] args) {
        Object obj = new Object();
        new Thread("顾客"){
            @Override
            public void run() {
                synchronized (obj){
                    System.out.println("告诉老板要什么包子");
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("吃包子");
                }
            }
        }.start();
        new Thread("老板"){
            @Override
            public void run() {
                synchronized (obj){
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("包子做好了");
                    obj.notify();
                }
            }
        }.start();
    }

//notifyAll()
public static void main(String[] args) {
        Object obj = new Object();
        new Thread("顾客1"){
            @Override
            public void run() {
                synchronized (obj){
                    System.out.println("顾客1告诉老板要什么包子");
                    try {
                        obj.wait(60000);//计时等待，等待超过时间，自动醒来，进入Runnable/Blocked状态
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("顾客1吃包子");
                }
            }
        }.start();
        new Thread("顾客2"){
            @Override
            public void run() {
                synchronized (obj){
                    System.out.println("顾客2告诉老板要什么包子");
                    try {
                        obj.wait(50000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("顾客2吃包子");
                }
            }
        }.start();
        new Thread("老板"){
            @Override
            public void run() {
                synchronized (obj){
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("包子做好了");
                    obj.notifyAll();//唤醒所有
                }
            }
        }.start();
    }
zezea
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值