【java基础】线程的生命周期、创建的两种方式及使用、线程的同步

wuchangjian2021-11-06 15:29:57编程学习

目录

 一、概念

1、程序、进程、线程

二、线程的创建和使用

1、通过继承Thread类的方式

2、通过实现Runnable接口的方式:

3、Thread类中的相关方法

4、线程优先级

三、线程的生命周期

 1、线程的几种状态

四、线程的同步

 1、同步代码块

2、同步方法


 一、概念

1、程序、进程、线程

 程序:是为了完成某个任务,利用某种语言编写的一组指令的集合,及指一块静态的代码

 进程:是程序的一次执行的过程,也可以是一个正在运行的程序,是一个动态的过程,有他自己产生、运行、消亡的过程-----------即生命周期。

         线程:进程可以进一步细化为线程,程序在运行中,内部的一条执行路径。若一个程序内部并行执行了多条路径,即为多线程。

                    而线程作为调度和执行的单位,拥有独立的运行栈和程序技术器,一个进程内的多个线程共享相同的内存单元和内存地址空间,从同一个堆中分配对象,访问相同的对象和变量。但是多个线程操作共享的变量和对象,会带来安全隐患

二、线程的创建和使用

1、通过继承Thread类的方式

步骤:

①:创建一个Thread的子类

②:重写Thrad类中run()方法,将执行此线程的操作声明在run()方法中

③:实例化当前子类的对象

④:调用Thread类中的start方法

//创建Thread子类
class MyThread extends Thread {

    //重写Thread类中run方法
    public void run() {

//将此线程执行的操作声明在run方法中
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.print(Thread.currentThread().getName() + ":" + i);//输出当前线程的线程名和i
            }
        }
    }
}

public class ThreadTest12 {
    public static void main(String[] args) {
//创建Thread子类的对象
        MyThread mt = new MyThread();
//调用start方法:1、启动当前线程;2、调用当前线程的run()方法
        mt.start();
    }
}

这种方式有两个问题:

①、我们不能通过直接调用run()方法来启动线程

②、再启动一个线程,不能让已经执行start()方法的线程去执行,否则会报错:

IllegalThreadStateException

2、通过实现Runnable接口的方式:

步骤:

①:创建一个实现了Runnable接口的类

②:重写Runnable类中的抽象方法:run()

③:创建此实现类的对象

④:将此实现类的对象作为参数传递到Thrad类的构造器中,创建Thread类的对象

⑤:调用Thread类中的start方法

class MyThread implements Runnable {

    public void run() {
//将此线程执行的操作声明在run方法中
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.print(Thread.currentThread().getName() + ":" + i);//输出当前线程的线程名和i
            }
        }

    }
}


public class ThreadTest {
    public static void main(String[] args) {
        //创建实现类的对象
        MyThread mt = new MyThread();
        //将此实现类的对象作为参数传递到THread构造其中,创建Thread类的对象
        Thread ta = new Thread(mt);//体现了多态性
        //调用Thread类中的start()方法
        ta.start();

        Thread ta1 = new Thread(mt);//体现了多态性
        ta1.start();//再启动一个线程,执行run方法,注意:此时两条线程操作同一个对象

    }


}

总结:比较两种线程创建的方式:

1、在开发中优先使用:实现Runnable接口的方式

原因:

①:实现的方式没有类的单继承的局限性

②:实现的方式更适合处理多线程有共享数据的情况

两者之间的练习:

①:Thread类本身也是实现了Runnable接口中的run方法

②:都需要重写run方法

③:都要将线程需要执行的操作声明在run方法中

3、Thread类中的相关方法

void start():启动线程,并执行对象的run()方法

run():线程再被调度是执行的操作

String getName():返回当前对象的名称

void setName(String name):设置当前线程的名称

static Thread currentThread():返回当前线程,在Thread子类中就是this,通常用于主线程和Runnable实现类

static void yield():线程让步,暂停当前正在执行的线程,把执行机会让给优先级相同或更高的线程

                                   若队列中没有同优先级的线程,则忽略此方法

join():当某个程序执行流中,调用其他线程的join方法时,调用线程将被阻塞,直到join方法加入的join方法执行完为止

static void sleep(long millis)(指定时间:毫秒):

①:令当前活动线程在指定时间内放弃对cpu的控制,使其他线程有机会被执行,时间到后重新排队

②:抛出InterruptedException异常

stop():强制结束线程声明周期,不推荐使用

boolean  isAlive:判断线程是否还活着

4、线程优先级

同优先级线程组成先进先出队列(先到先服务),使用时间片策略

对优先级线程,采用优先调度的抢占式策略(高优先级的线程抢占CPU)

线程的优先级等级:

MAX_PRIORITY:10

MIN_PRIORITY:1

NORM_PRIORITY:5

涉及的相关方法:

getPriority()返回相关线程的优先级登记

setPriority(int newPriority)设置相关线程的优先级登记 

注意点:

线程创建时继承父线程的优先级

低优先级的只是获得调度的概率低,并非一定是高优先级完成后才能调度

三、线程的生命周期

 1、线程的几种状态

四、线程的同步

前序:当某个线程在执行的过程中,尚未完成操作时,        其他线程参与进来,会导致线程安全问题,以下两种方式可以解决(思路:当一个线程在操作共享数据时,让其他线程不能参与进来,直到线程a操作完,其他线程才能进来,这样即使线程a发生阻塞,也不能被改变)

 1、同步代码块

synchronized(同步监视器){  //同步监视器:俗称:锁,任何一个类的对象都可以称当锁,要求多个线程必须共用一把锁!

//需要被同步的代码

}

①:继承Thread子类的方式结合同步代码块

//创建Thread子类
class MyThread extends Thread {

    //重写Thread类中run方法
    public void run() {

synchroinzed(this){ //可以使用当前对象,不过继承Thread类的方式慎用this
//将此线程执行的操作声明在run方法中
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.print(Thread.currentThread().getName() + ":" + i);//输出当前线程的线程名和i
                }
            }
        }
    }
}

public class ThreadTest12 {
    public static void main(String[] args) {
//创建Thread子类的对象
        MyThread mt = new MyThread();
//调用start方法:1、启动当前线程;2、调用当前线程的run()方法
        mt.start();
    }
}

②:实现Runnable接口的方式结合同步代码块

class Window1 implements Runnable{
    private int ticket = 100;
    Object obj = new Object();
    @Override
    public void run() {
        while (true){
            synchronized(this) { //使用当前对象也可以,此时的this:唯一的window1的对象
                if (ticket > 0) {

                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }

                    System.out.println(Thread.currentThread().getName() + ":" + ticket);
                    ticket--;
                } else {
                    break;
                }
            }
        }
    }
}

public class WindowTest1 {
    public static void main(String[] args) {
        Window1  w = new Window1();
        Thread t =new Thread(w);
        Thread t1 =new Thread(w);
        Thread t2=new Thread(w);
        t.start();
        t1.start();
        t2.start();
    }
}

2、同步方法

①:通过实现Runnable接口的方式结合同步方法

//使用同步方法解决实现Runnable接口的线程安全问题
 
class Window3 implements Runnable {
    private int ticket = 1000;

    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    public synchronized void show() { //同步监视器:this
        //  synchronized (this) {
        if (ticket > 0) {
/*                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }*/
            System.out.println(Thread.currentThread().getName() + ":" + ticket);
            ticket--;
        }
        //   }
    }

}


public class WindowTest3 {
    public static void main(String[] args) {
        Window3 w = new Window3();
        Thread t = new Thread(w);
        Thread t1 = new Thread(w);
        Thread t2 = new Thread(w);
        t.start();
        t1.start();
        t2.start();
    }
}

②:通过继承Thread类的方式结合同步方法

/**使用同步方法处理继承Thread类的方式中的线程安全问题
 *
 * 关于同步方法的总结:
 * 1、同步方法仍然涉及到同步监视器,只是不需要我们显式的声明
 * 2、非静态的同步方法,同步监视器是:this
 *    静态的同步方法:同步监视器是当前类本身
 *
 */
class Window4 extends Thread {

    private static int ticket = 100;

    //变成唯一,使用static


    @Override
    public void run() {
        while (true) {
            show();
        }
    }

    private static synchronized void show() {//同步监视器:Window.class
        //private synchronized void show()//这种方法是错的,进来的是三个对象
        if (ticket > 0) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "卖票,票号为:" + ticket);
            ticket--;
        }
    }
}

public class WindowTest4 {
    public static void main(String[] args) {
        Window4 w = new Window4();
        Window4 w1 = new Window4();
        Window4 w2 = new Window4();

        w.setName("窗口1");
        w1.setName("窗口2");
        w2.setName("窗口3");

        w.start();
        w1.start();
        w2.start();
    }
}

 

相关文章

机器学习开发框架

目录 1.什么使机器学习开发框架 2.机器学习框架和深度学习框架的关系  3....

在这里插入图片描述Redis

Redis

...

发表评论    

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。