线程

发布于 2022-04-29  88 次阅读


基本介绍

程序

是为了完成特定的任务。用某种语言编写的一组指令的集合,简单来说就是我们写的代码

进程

1.进程是指运行中的程序,比如我们打开一个软件,就启动了一个进程,操作系统就会为该进程分配内存空间。

2.进程是程序的一次执行过程,或是正在运行的一个程序,是动态过程:有它自身的产生、存在和消亡的过程、

线程

1.线程是进程创建的,是进程的一个实体

2.一个进程可以拥有多个进程

一些线程概念

1.单线程:同一个时刻,只允许执行一个线程

2.多线程:同一个时刻,可以执行多个线程,比如:多窗口聊天,同时下载多个文件

3.并发:同一个时刻,多个任务交替执行,造成一种“貌似同时”的错觉,简单来说,单核cpu实现的多任务就是并发

4.并行:同一时刻,多个任务同时执行。多核cpu可以实现并行

创建线程的两种方式

1.继承Thread类,重写run方法

2.实现Runnable接口,重写run方法

第一个方法例子——继承Thread类

public static void main(String[] args) throws InterruptedException {
        int i=0;
        Cat cat = new Cat();
        cat.start();
        while(i<=60) {
            System.out.println("mian" + (++i));
            Thread.sleep(1000);
        }
    }
}
class Cat extends Thread {
    int i=0;
        public void run () {
            while(true)
            {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
                System.out.println("喵" + (++i));
                if(i==80){
                    break;
                }

    }
    }
}

第二个方法例子——实现Runnable接口

  public static void main(String[] args) throws InterruptedException {
        int i=0;
        Cat cat = new Cat();
        Thread thread = new Thread(cat);
        thread.start();
        while(i<=60) {
            System.out.println("mian" + (++i));
            Thread.sleep(1000);
        }
    }
}
class Cat implements Runnable {
    int i=0;
        public void run () {
            while(true)
            {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
                System.out.println("喵" + (++i));
                if(i==80){
                    break;
                }

    }
    }
}

线程终止

基本说明

1.当线程完成任务后,会自动退出

2.还可以通过使用变量来控制run方法退出的方式停止线程,即通知方式

线程常用方法(一)

1.setName:设置线程名称,使之与参数name相同

2.getName:返回该线程的名称

3.start:使该线程开始执行;java虚拟机底层调用该线程的star0方法

4.run:调用线程对象run方法

5.setpriority:更改线程的优先级

6.getpriority:获取线程的优先级

7.sleep:在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)

8.interrupt:中断线程

细节

1.start底层会创建新的线程,调用run,run就是一个简单的方法调用,不会启动新线程

2.线程优先级的范围

3.interrupt,中断线程,但并没有真正的结束线程。所以一般用于中断正在休眠的线程

4.sleep:线程的静态方法,使线程休眠

常用方法(二)

1.yield:线程的礼让。让出cpu,让其他线程执行,但礼让的时间不确定,所以也不一定礼让成功

2.join:线程的插队。插队的线程一旦插队成功,则肯定先执行完插入的线程所有的任务

用户线程和守护线程

1.用户线程:也叫工作线程,当线程的任务执行完或通知方式结束

2.守护线程:一般是为了工作线程服务的,当所有的用户线程结束,守护线程自动结束

调用setDaemon(true)

线程同步

1.在多线程编程,一些敏感数据不允许被多个线程同时访问,此时就使用同步访问技术, 保证数据在任何同一时刻,最多有一个线程访问,以 保证数据的完整性

2.也可以这里理解 :线程同步,即当有一个线程在对内存进行操作时,其他线程都不可以对这个内存地址进行操作,直到该线程完成操作,其他线程才能对该内存地址进行操作

1.同步代码块——得到对象的锁,才能操作同步代码

synchronized(对象){

需要被同步的代码

}

2.synchronized还可以放在方法声明中,表示整个方法-为同步方法

public synchronized void m(String name){

要被同步的代码

}

例子

    public static void main(String[] args) throws InterruptedException {
        Cat cat = new Cat();
        Thread thread1 = new Thread(cat);
        thread1.setName("t1");
        Thread thread2 = new Thread(cat);
        thread2.setName("t2");
        thread1.start();
        thread2.start();
    }
    }


class Cat implements Runnable {
    private int age = 10000;
    public void run() {
        while (true) {
            synchronized (this) {
                if (age < 1000) {
                    break;
                }
                age -= 1000;
                System.out.println(Thread.currentThread().getName() + "余额" + age);
            }
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

互斥锁

基本介绍

1.java语言中,引入了对象互斥锁的概念,来保证共享数据操作的完整性

2.每个对象都对应于一个可称为“互斥锁”的标记,这个标记用来保证在任意时刻,只能有一个线程访问该对象

3.关键字synchronized来与对象的互斥锁联系。当某个对象用synchronized修饰时,表明该对象在任意时刻只能由一个线程访问

4.同步的局限性:导致程序的执行效率降低

5.同步方法:(非静态的)的锁可以是this,也可以是其他对象(要求事同一个对象)

6.同步方法(静态的)的锁为当前类本身

细节

1.同步方法如果没有使用static修饰:默认锁对象为this

2.如果方法使用static修饰,默认锁对象:当前类.class

3.实现的落地步骤:

需要先分析上锁的代码

选择同步代码块或者同步方法

要求多个线程的锁对象为同一个即可

线程的死锁

多个线程都占用了对方的锁资源,但不肯相让,导致了死锁,

释放锁

1.当前线程的同步方法、同步代码块执行结束

2.当前线程在同步代码块、同步方法中遇到break、return。

3.当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束

4.当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁

下面操作不会释放锁

1.线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行,不会释放锁

2.线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁;

提示:应尽量避免使用suspend()和resume()来控制线程,方法不再推荐使用