java学习--day22(进程&线程)

文章目录

      • 1.什么是进程
      • 2.什么是线程
      • 3.线程和进程的区别【面试题】
      • 4.并发和并行
      • 5.创建线程的两种方式【重点】
        • 1.继承Thread
        • 2.实现Runnable接口
      • 6.线程下面的几个方法
      • 7.线程的同步和锁【重要】

1.什么是进程

是独立的运行程序

​ 比如咱们电脑软件,你启动起来以后,他就是一个进程。qq idea

进程需要windows系统的分配。可以获取当前的系统的网卡,内存,显卡等

​ 1.独立性

​ 各个进程之间是相互的独立的互不影响 的。录屏软件和idea没有关系的

​ 2.互斥性

​ 每个软件系统都会分配一个独立端口号,如果启动一个软件以后他的端口号97。

​ 如果再启动另外一个软件,另外一个软件如果端口也是97,这个程序就启动不了,端口被占用的

脑海里面知道开启的软件就是一个进程 即可!!!

2.什么是线程

进程是由多个或者一个线程组成的。每个进程至少得有一个线程的支撑。

脑海里面这样来想,一个进程(qq),qq里面很多个线程在执行。线程的执行

支撑起来了进程的执行。

把一个人比作一个进程,那么你身体里面的细胞就是线程。如果没有细胞。这个人还存在吗?不存在的!!!

进程包含了线程,线程是组成进程的最小基本单位

​ 特性:

​ 1.抢占式运行的【重要】

​ CPU在执行的时候,按照时间片来执行的,单位的时间片是抢占是执行

​ 比如 idea qq 抢占CPU的,比如qq的线程抢到cpu,idea线程等待

​ 我是一个cpu。你们问我问题。75个线程。同时来问我问题吗?不是

​ 抢着问。一个问。然后其他人等待。这个人甚至还没有问完,其他的某一个人

​ 抢到我了,他问我。大概就是效果

​ 2.资源共享性

​ 一个线程可以共享当前CPU, 网卡等

Java程序:

​ 一个Java程序就是一个进程 Demo1 就是一个应用程序 就是一个进程

​ 一个Java程序Demo1里面至少 几个线程?

​ 两个:

​ main主函数线程

​ JVM垃圾回收器线程

3.线程和进程的区别【面试题】

进程是一个应用程序,是独立的
线程是进程中最小的基本单位。
把进程比作生产车间,每个流水线就是一个线程
进程有独立性和互斥性
线程有抢占式资源共享特性

4.并发和并行

并发:同时发生,轮流交替执行

并行:真正意义的同时执行

比如:

​ 你去饭店点了两个菜,生活中拿个筷子轮流夹菜哦这就是并发场景

​ 端起盘子,同时倒到嘴里面,这就是并行场景

5.创建线程的两种方式【重点】

1.继承Thread

创建线程的两种方式

  1. 一个是将一个类声明为Thread的子类。 这个子类应该重写run方法 。 然后可以分配并启动子类的实例。
package com.qfedu.a_thread;

// 一个是将一个类声明为Thread的子类。
// 这个子类应该重写run类的方法Thread 。
// 然后可以分配并启动子类的实例。
class MyThread1 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("我是myThread1线程:" + i);
        }
    }
}
class MyThread2 extends Thread {
    @Override
    public void run() {//run方法中写功能代码  就是一个线程中执行的一个功能
        for (int i = 0; i < 500; i++) {
            System.out.println("我是mythread2线程:" + i);
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //官方手册中说,要去实例化Thread的子类,并启动线程
        MyThread1 myThread1 = new MyThread1();
        //启动线程 使用start方法  在主线程中开启子线程
        myThread1.start();
        MyThread2 myThread2 = new MyThread2();
        myThread2.start();
        //现在有几个线程?  3个
        //一个是MyThread1线程  一个是主线程(main)  一个垃圾回收机制线程
        for (int i = 0; i < 500; i++) {
            System.out.println("主函数线程:" + i);
        }
        //发现先执行了主线程,然后再执行子线程,然后又执行主线程
        //这就线程的抢占式的运行
        //三个线程:
        //你自己吃三盘菜,咋吃?
        //一盘菜代表一个线程,一盘菜夹一下,随机的吧。
        //开启一个线程,就是在执行一个任务。
        //上面这个代码,你们执行结果和我执行的结果一样吗?绝对不一样的
        //抢占式的,随机执行线程的!!!

    }
}
练习:
            main主线程 打印100遍的吃大盘鸡
            子线程1 打印100遍的吃水煮肉片
            子线程2 打印100遍的吃毛血旺
            一定要注意打印的结果,多执行几遍,看看每次执行的结果是否一样!!!
2.实现Runnable接口

另一种方法来创建一个线程是声明实现类Runnable接口。 那个类然后实现了run方法。 然后可以分配类的实例,在创建Thread时作为参数传递,并启动。

package com.qfedu.a_thread;

//另一种方法来创建一个线程是声明实现类Runnable接口。
// 那个类然后实现了run方法。 
// 然后可以分配类的实例(创建类的对象),在创建Thread实例时作为参数传递,并启动。
class MyThread3 implements Runnable {


    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread3:" + i);
        }
    }
}
class MyaThread4 implements Runnable {

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread4:" + i);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MyThread3 myThread3 = new MyThread3();
        //Thread(Runnable target)  参数是Runnable这个接口对象
        //分配一个新的 Thread对象。
        Thread thread = new Thread(myThread3);
        thread.start();
        MyaThread4 myaThread4 = new MyaThread4();
        Thread thread1 = new Thread(myaThread4);
        thread1.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("main主线程:" + i);
        }
        //有几个线程做任务的线程  3个 一个是main主线程  一个是MyThread3
        //一个MyThread4这个线程
        //可以发现运行的结果是随机执行的!!!

    }
}

6.线程下面的几个方法

构造方法

Thread()分配一个新的 Thread对象。 无参构造方法
Thread(Runnable target)分配一个新的 Thread对象。 有参构造
Thread(Runnable target, String name)分配一个新的 Thread对象。并起名字

线程方法:

static Thread currentThread()返回对当前正在执行的线程对象的引用
String getName()返回此线程的名称。
void setName(String name)将此线程的名称更改为等于参数 name
int getPriority()返回此线程的优先级。
void setPriority(int newPriority)更改此线程的优先级。
设置优先并不一定优先,只是增加了执行的概率。最小值是1,最大值是10,默认的是5
static void sleep(long millis)使当前正在执行的线程以指定的毫秒数暂停(暂时停止执行),具体取决于系统定时器和调度程序的精度和准确性。
package com.qfedu.b_threadfun;

class MyThread1 implements Runnable {
    @Override
    public void run() {
        Thread thread = Thread.currentThread();
        //此时这个thread对象是MyThread1这个线程
        //对子线程设置名字
        thread.setName("mythread1子线程");
        System.out.println(thread.getName());//Thread-0
    }
}
class MyThread2 implements Runnable {
    @Override
    public void run() {
        Thread thread = Thread.currentThread();
        System.out.println(thread.getName());//狗蛋
    }
}
public class Demo1 {
    public static void main(String[] args) {
        //currentThread() 获取当前线程对象
        Thread thread = Thread.currentThread();
        //现在thread  这个对象是哪个线程?主线程
        //为啥是main主线程
        //给main主线程设置名字
        thread.setName("主线程");
        //获取的是main主线程的名字,Jvm会给主线程还有其他线程一个默认的名字

        System.out.println(thread.getName());//main
//        MyThread1 myThread1 = new MyThread1();
//        Thread thread1 = new Thread( myThread1);
//        thread1.start();

        new Thread(new MyThread1()).start();
        //Java中默认的主线程叫main  子线程叫Thread-0  Thread-1....
        //默认的有名字,咱们能不能对线程自定义名字?能

        //我在启动MyThread2的这个线程的时候顺便起名字
        MyThread2 myThread2 = new MyThread2();
        //myThread2线程的名字就叫狗蛋,是在创建线程的时候就已经起好名字了
        Thread thread1 = new Thread(myThread2, "狗蛋");
        thread1.start();


    }
}

package com.qfedu.b_threadfun;

class MyThread3 implements Runnable {
    @Override
    public void run() {
        //想看一下MyThread3这个线程的优先级是几
        Thread thread = Thread.currentThread();
        thread.setPriority(10);
        System.out.println(thread.getPriority());
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread3线程:" + i);
        }
    }
}
class MyThread4 implements Runnable {
    @Override
    public void run() {
        //想看一下MyThread3这个线程的优先级是几
        Thread thread = Thread.currentThread();
        thread.setPriority(1);
        System.out.println(thread.getPriority());
        for (int i = 0; i < 100; i++) {
            System.out.println("MyThread4线程:" + i);
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {

        //默认的优先级都是5,能不能手动去修改某一个线程的优先级?
        //可以
        Thread thread = Thread.currentThread();
        //主线程的优先级设置1
        //thread.setPriority(1);
        //获取主线程的优先级
        System.out.println(thread.getPriority());//5
        //优先级  1 ~10  1的优先级最低  10的优先级最高
        //jvm默认线程的优先级是5
//        for (int i = 0; i < 100; i++) {
//            System.out.println("主线程:" + i);
//        }
        new Thread(new MyThread3()).start();
        new Thread(new MyThread4()).start();
        //所以优先级不要用啦!!!并不一定真正的优先!!!
        //线程执行的结果不可控!!!很尴尬!!!
    }
}

package com.qfedu.b_threadfun;

class MyThread5 implements Runnable {
    @Override
    public void run() {
        try {
            //发现 Thread.sleep 有一个运行时异常,
            //但是发现没有抛出,只有try-catch 为啥?
            //sleep方法写在了run方法中了,因为
            //run方法是重写的, 父类的 public abstract void run();
            //父类有抛出吗?没有抛出,重写是比较严格的
            //父类没有抛出,子类也同样不能抛出
            Thread.sleep(10000);//10秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        for (int i = 0; i < 500; i++) {
            System.out.println("MyThread5:" + i);
        }
    }
}
class MyThread6 implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 500; i++) {
            System.out.println("MyThread6:" + i);
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        new Thread(new MyThread5()).start();
        new Thread(new MyThread6()).start();
        //发现运行的结果是不可控的,是随机的抢占式的
        //咱们接下来学习一个东西叫sleep  让某一个线程睡一会儿
        //这个线程在睡觉的期间不会去抢占cpu  不执行
        //现在我让MyTread5睡了一会儿。就意味着绝对MyThread6线程先执行
        //实现可控的效果
        //思考:sleep方法再开发的时候敢用不敢用?
        //不敢用。睡多久你知道吗?睡多久合适?不能确定
        //cpu最大利用化。不可能让cpu闲置
        //如果sleep睡眠时间少的话,还是抢占
        //如果sleep睡眠你时间太长的话,就会cpu就会闲置
        //没有办法把控的!!! 接下来要学习锁!!!
    }
}

回顾:

1.新建线程的两种方式
	1.继承Thread
	2.实现Runnable接口【开发要用的】
	代码要自己学会写的!!!
2.线程的方法
	Thread.currentThread();获取当前线程对象
	setPriority();设置优先级的
	getPriority(); 获取当前线程的优先级
	getName();得到线程的名字
	setName();设置线程的名字
	sleep();线程的休眠
	

7.线程的同步和锁【重要】

为什么要进行线程的同步?

Java是允许多线程(多个线程),当多个线程操作同一个资源(咋操作)的时候,会导致得到或者打印的数据不准确。从而发生冲突。咋解决?加同步锁。

美团
淘票票
这个两个线程,都去麦同一场次的票
结果美团卖出去一张1排1列的票
结果淘票票也卖出去了1排1列的票  你感觉合适吗?
就是上面的这种结果!!!不合适的,分享同一个资源的时候,要保证分享资源的数据,合法性!!!



分析结果:
	
package com.qfedu.c_sync;

//最理想的状态!!!
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了, 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是:有可能两个线程同时进入到while循环
//
class MySync implements Runnable {
    int ticket = 50;
    @Override
    public void run() {
        //
        while (true) {//死循环
            //两个线程都进入到了循环了
            //此时两个线程所持有的ticket 都是50
            //但是两个线程都要往下执行
            //有可能线程1 先执行了sout(50)  线程2在等待哦!!!
            //线程1执行了--操作并出了循环 线程1ticket = 49
            //线程1又抢到循环了 sout(49) tiket--
            //再进入倒这个循环,有可能线程2抢到这个执行权
            //线程2要往下执行输出语句  ticket=50 打印50
            if (ticket > 0) {
                //线程具有抢占式的运行
                //咱们有没有可能,线程3进入到if语句
                //此时线程1也进入到if语句了
                //线程3去打印 卖出了50张票
                //在线程1里面  ticket=50
                //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                //线程1又抢到资源要执行,执行输出语句  tiekct=50
                System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                ticket--;
            } else {
                System.out.println("买完了");
                break;//终止循环!!!
            }
        }
    }
}
public class Demo1 {
    public static void main(String[] args) {
        MySync mySync = new MySync();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();


    }
}

解决方案:

​ 1.同步方法:使用一个关键字synchronized修饰方法。因为Java对象都有一个内置的锁对象。当使用这个关键字的时候,修饰方法的时候,这个方法就会被锁保护起来被锁锁住

当一个线程进来以后,会立马锁住当前的方法。意味着只有一个线程进来,其他线程都在外面等着。

public synchronized  void run () {

}
package com.qfedu.c_sync;

//最理想的状态!!!
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了, 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是:有可能两个线程同时进入到while循环
//
class MySync1 implements Runnable {
    int ticket = 50;
    //对这个run方法加了锁 就意味着只有一个线程进入到run方法中
    //其他线程都在run方法外面等待
    @Override
    public synchronized void run() {
        //
        while (true) {//死循环
            //两个线程都进入到了循环了
            //此时两个线程所持有的ticket 都是50
            //但是两个线程都要往下执行
            //有可能线程1 先执行了sout(50)  线程2在等待哦!!!
            //线程1执行了--操作并出了循环 线程1ticket = 49
            //线程1又抢到循环了 sout(49) tiket--
            //再进入倒这个循环,有可能线程2抢到这个执行权
            //线程2要往下执行输出语句  ticket=50 打印50
            if (ticket > 0) {
                //线程具有抢占式的运行
                //咱们有没有可能,线程3进入到if语句
                //此时线程1也进入到if语句了
                //线程3去打印 卖出了50张票
                //在线程1里面  ticket=50
                //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                //线程1又抢到资源要执行,执行输出语句  tiekct=50
                System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                ticket--;
            } else {
                System.out.println("买完了");
                break;//终止循环!!!
            }
        }
    }
}
public class Demo2 {
    public static void main(String[] args) {
        MySync1 mySync = new MySync1();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();

        //为啥都是线程1卖出去的票?
        //很巧  线程1抢到执行权了,进入到run方法中
        //线程2和线程3在外面等着。
        //一个循环进来以后,把循环全部执行完!!!
        //会出现一家独大的情况!!!也是不符合咱们生活场景的!!!
        //咋解决?咱们 不能方法中加锁,在其他地方加锁


    }
}

换另外一种解决方法:

​ 同步代码块:就是拥有了synchronized 关键字修饰一个语句块。被修饰的语句块会被加锁。从而实现同步。

语法格式:

synchronized  (this) {
	被加锁的代码块
}
package com.qfedu.c_sync;

//最理想的状态!!!
//先线程1进入到ticket=50,循环 循环结束以后 此时
//tiket=49了
//循环第二次的时候 线程2抢到资源了 此时ticket=49
//循环 打印49 tiket-- ticket=48了
//循环第三次的时候 线程2 抢到资源了, 此时ticket=48
//打印卖第48张票。ticket--  tiket=47
//线程1又抢到循环
//现在的情况是:有可能两个线程同时进入到while循环
//
class MySync2 implements Runnable {
    int ticket = 500;
    //对这个run方法加了锁 就意味着只有一个线程进入到run方法中
    //其他线程都在run方法外面等待
    @Override
    public  void run() {
        //能不能对循环加锁?不能 因为循环加锁以后,还是一个线程循环完,没有任何意义

        while (true) {//死循环
            //if语句加了锁以后
            //就意味着只有一个线程进入到if语句
            //假如线程1进入if语句了,线程2和线程3就会等待
            //线程1打印50 并--  ticket变量为49
            //线程2抢到了49 sout(49) tiket--  48
            //其他线程再抢!!!

            //核心业务 加了锁,只让一个线程进入,操作完以后。锁释放掉
            //然后这三个线程再抢。还只能进一个,再操作核心业务
            synchronized (this) {//只能让一个线程进入操作,其他线程在外面等待排队
                if (ticket > 0) {
                    //线程具有抢占式的运行
                    //咱们有没有可能,线程3进入到if语句
                    //此时线程1也进入到if语句了
                    //线程3去打印 卖出了50张票
                    //在线程1里面  ticket=50
                    //线程3又抢到ticket-- 又进入到循环了  ticket = 49
                    //线程3又抢到了ticket-- 又进入倒循环 ticket=48
                    //线程1又抢到资源要执行,执行输出语句  tiekct=50
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                    ticket--;
                } else {
                    System.out.println("买完了");
                    break;//终止循环!!!
                }
            }
        }
    }
}
public class Demo3 {
    public static void main(String[] args) {
        MySync2 mySync = new MySync2();
        //这三个线程
        Thread thread1 = new Thread(mySync, "线程1");
        thread1.start();
        Thread thread2 = new Thread(mySync, "线程2");
        thread2.start();
        Thread thread3 = new Thread(mySync, "线程3");
        thread3.start();

        //为啥都是线程1卖出去的票?
        //很巧  线程1抢到执行权了,进入到run方法中
        //线程2和线程3在外面等着。
        //一个循环进来以后,把循环全部执行完!!!
        //会出现一家独大的情况!!!也是不符合咱们生活场景的!!!
        //咋解决?咱们 不能方法中加锁,在其他地方加锁


    }
}

针对于同步代码块举个例子:

​ 上厕所的时候,有坑位,这个坑位就是资源。

​ 三个人去抢这个资源,如果不加锁的话,会出现问题的?是的。加上锁以后就会保证数据准确性。

案例:

加锁的目的为了保证数据的准确性。
卖电影票:
	三个线程:
		淘票票
		美团
		猫眼
		100张票
package com.qfedu.c_sync;

class SaleTicket implements Runnable {
    //声明一个变量票
    //静态的变量和对象没有关系了
    private static int ticket = 100;
    @Override
    public void run() {
        //美团



        while (true) {
            //美团  猫眼  淘票票
            synchronized (this) {
                if (ticket > 0) {
                    //淘票票  和猫眼同时进入到if语句,但是都没有执行ticket--这个操作
                    System.out.println(Thread.currentThread().getName() + "卖出了第" + ticket + "票");
                    //所以会打印 淘票票 100   猫眼100

                    ticket--;
                } else {
                    System.out.println("卖完了");
                    break;
                }
            }
        }

    }
}
public class Demo4 {
    public static void main(String[] args) {
        SaleTicket saleTicket = new SaleTicket();
        new Thread(saleTicket, "淘票票").start();
        new Thread(saleTicket, "美团").start();
        new Thread(saleTicket, "猫眼").start();
        //淘票票卖出了第100票
        //猫眼卖出了第100票
        //淘票票卖出了第99票
        //淘票票卖出了第97票
        //淘票票卖出了第96票
        //淘票票卖出了第100票
        //淘票票卖出了第99票
        //猫眼卖出了第98票
        //猫眼卖出了第97票

    }
}

线程就是这样,不可控制,但是可以加锁。让他可控制。

你可能感兴趣的:(Java基础,java)