十.IDEA的使用与多线程

最新推荐文章于 2024-06-12 16:20:20 发布

ASDWYang

最新推荐文章于 2024-06-12 16:20:20 发布

阅读量2.1k

点赞数

分类专栏： JAVA 文章标签： intellij-idea java intellij idea

本文链接：https://blog.csdn.net/m0_47489229/article/details/120876210

版权

JAVA 专栏收录该内容

40 篇文章 3 订阅

订阅专栏

教程来源：	java基础到高级_零基础自学Java–尚硅谷–宋红康
教程视频地址：	java基础到高级_零基础自学Java--尚硅谷--宋红康_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1ny4y1Y7CW

8.模板（Templates）的使用和设置

9.程序进程线程的概念

10.单核与多核CPU的任务执行-单行与并发

11.多线程的优点

12.创建多线程的方式一：继承Thread类

17.例题：继承Thread方式，多窗口卖票

18.创建多线程方式二：实现Runnble接口

19.例题：实现Runnable方式，多窗口卖票

20.两种创建方式的对比

21.每日一考

1.IDEA的使用与多线程的概述

对于将来的学习进行了一个基本的介绍

2.IDEA的卸载

InerlliJ IDEA 2017.3.1版本
.metadata之中放置相应的配置------类似于config
理解config与system(是一些缓存)
卸载完软件重启一下电脑

3.IDEA的介绍

Eclipse->IBM
具体的介绍了一节课

4.IDEA的安装

本节博主是在某多多买的，你懂的哈。支持一下正版哈！
安装好之后，在View下面将Toolbar以及ToolButtons勾上

package com.atguigu.java;
public class HelloWorld {
    public static void main(String[] args) { //这里使用的是psvm + 回车
        System.out.println("hello world!"); //这里使用的是sout + 回车 或者使用helloworld.sout
        System.out.println("Yang");
    }
}

5.Module的理解和创建

模块相当于一个project（Eclipse之中）
删除操作:1.进行Remove Module； 2.Opening Module Setting 再点击减号即可。（只是一个普通的文件目录，可以进行删除）---防止误操作

6.IDEA的常用设置

本节课涉及到的知识点比较多，跟着老师的思路走，第一次直接设置好便可以，这里就不写具体的操作说明了。

7.快捷键的设置

keymap - 由上图可知，左侧是进行功能的查找，右侧是进行相应的快捷键的查找。

8.模板（Templates）的使用和设置

Editor-General-Postfix Completion

9.程序进程线程的概念

线程的创建方式有四种（面试题）
程序：是为了完成特定的任务、用某种语言编写的一组指令的集合。即而指一段静态的代码，静态对象。
进程：是程序执行一次的过程，或者是正在一个正在运行的一个程序。是一个动态的过程：有它自身的产生、存在和消亡的过程。 ------生命周期
线程：进程进一步可以分为线程，是程序执行的一条路径。

如果一个进程同一时间并行执行多个线程，就是支持多线程的。
线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器（pc），线程切换开销小。
一个进程中的多个线程共享相同的内存单元/内存地址空间，它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。

10.单核与多核CPU的任务执行-单行与并发

1.单核CPU和多核CPU的理解---一核有难，七核围观（太好笑了）

单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把他“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。
如果是多核的话，才能更好的发挥多线程的效率。（现在的服务器都是多核的）
一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc() 垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

2.并行与并发---一入java深似海，从此对象成路人

并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。（不同的人做不同的事）
并发：一个CPU(采用时间片)“同时”执行多个任务。比如：秒杀、多个人做同一件事。

11.多线程的优点

多线程的优点：

1. 提高应用程序的响应。对图形化界面更有意义，可增强用户体验。

2. 提高计算机系统CPU的利用率

3. 改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

什么时候需要进行多线程？

1. 程序需要同时执行两个或多个任务。

2. 程序需要实现一些需要等待的任务时，如用户输入、文件读写操作、网络操作、搜索等。

3. 需要一些后台运行的程序时。

12.创建多线程的方式一：继承Thread类

下面的的代码并不是一个多线程的过程

package com.atguigu.java;

/**
 * @anthor shkstart
 * @create 2021-11-0210:42
 */
public class Sample {
    public void method1(String str)
    {
        System.out.println(str);
    }
    public void method2(String str)
    {
        method1(str);
    }

    public static void main(String[] args) {
        Sample s = new Sample();
        s.method2("hello");
    }
}

下面是一个线程相应的代码

package com.atguigu.java;
/**
 * 多线程的创建：方式一：继承于Thread类
 * 1.创建一个继承于Thread的子类
 * 2.重写Thread类的run（）方法 -- 针对于方法体的，我们要将执行的操作声明在run（）方法之中
 * 3.创建Thread类的子类对象
 * 4.通过此对象调用start（）
 * 例子：遍历100以内的所有的偶数。
 * @anthor shkstart
 * @create 2021-11-0210:49
 */
//1.创建一个继承于Thread的子类
    class MyThread extends Thread
{
    //2.重写Thread类之中的run（）
    @Override
    public void run()
    {
        super.run();
        for(int i = 0; i < 100; i++)
        {
            if(i%2==0)
            {
                System.out.println(i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread myThread = new MyThread(); //使用alt + enter将相应的格式进行补充
        //4.调用相应的start方法
        myThread.start();
        //System.out.println("hello");
        for(int i = 0; i < 100;i++)
        {
            if(i%2 == 0)
            {
                System.out.println(i + "*********main**********");
            }
        }
    }
}

13.创建过程中两个问题的说明

package com.atguigu.java;
/**
 * 多线程的创建：方式一：继承于Thread类
 * 1.创建一个继承于Thread的子类
 * 2.重写Thread类的run（）方法 -- 针对于方法体的，我们要将执行的操作声明在run（）方法之中
 * 3.创建Thread类的子类对象
 * 4.通过此对象调用start（）;①启动线程 ②调用当前线程的run（）方法
 * 例子：遍历100以内的所有的偶数。
 *
 *
 * @anthor shkstart
 * @create 2021-11-0210:49
 */
//1.创建一个继承于Thread的子类
    class MyThread extends Thread
{
    //2.重写Thread类之中的run（）
    @Override
    public void run()
    {
        super.run();
        for(int i = 0; i < 100; i++)
        {
            if(i%2==0)
            {
                //System.out.println(i);
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类对象
        MyThread myThread = new MyThread(); //使用alt + enter将相应的格式进行补充
        //4.调用相应的start方法
        myThread.start();//问题一：我们不能直接使用run（）启动线程
        //myThread.run(); 使用run（）是不可以的，因为如果要是使用run（）会导致先执行run（）之中的内容，再执行 System.out.println(i + "*********main**********");
        //System.out.println("hello");
        //下面的操作仍然是在main（）线程之中执行的；
        //问题二：再启动一个线程，遍历100以内的偶数 。不可以让已经start（）的线程去执行。会报IllegalThreadStateException
        //myThread.start();  Exception in thread "main" java.lang.IllegalThreadStateException
        MyThread myThread1 = new MyThread();
        myThread1.start();
        for(int i = 0; i < 100;i++)
        {
            if(i%2 == 0)
            {
                System.out.println(i + "*********main**********"+Thread.currentThread().getName()+":"+i);
            }
        }
    }
}

14.继承方式的课后练习

每次执行的效果是不一样的

package com.atshanguigu.exer;

/**
 * 练习：创建两个分线程，其中一个遍历100以内的偶数，另一个遍历100以内的奇数
 *
 *
 * @anthor shkstart
 * @create 2021-11-0211:48
 */
public class ThreadDemo {
    public static void main(String[] args) {
    MyThread1 mythread1 = new MyThread1();
    MyThread2 mythread2 = new MyThread2();
    mythread1.start();
    mythread2.start();

    }
}
class MyThread1 extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0;i < 100; i++)
        {
            if(i%2 == 0)
            {
                System.out.println(Thread.currentThread().getName()+"这是偶数");
            }
        }
    }
}
class MyThread2 extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0; i < 100;i++)
        {
            if(i%2!=0)
            {
                System.out.println(Thread.currentThread().getName()+"这是奇数");
            }
        }
    }
}

例题

package com.atshanguigu.exer;

/**
 * 练习：创建两个分线程，其中一个遍历100以内的偶数，另一个遍历100以内的奇数
 *
 *
 * @anthor shkstart
 * @create 2021-11-0211:48
 */
public class ThreadDemo {
    public static void main(String[] args) {
    MyThread1 mythread1 = new MyThread1();
    MyThread2 mythread2 = new MyThread2();
    mythread1.start();
    mythread2.start();

    }
}
class MyThread1 extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0;i < 100; i++)
        {
            if(i%2 == 0)
            {
                System.out.println(Thread.currentThread().getName()+"这是偶数");
            }
        }
    }
}
class MyThread2 extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0; i < 100;i++)
        {
            if(i%2!=0)
            {
                System.out.println(Thread.currentThread().getName()+"这是奇数");
            }
        }
    }
}

另一种方式，通过匿名子类进行调用

package com.atshanguigu.exer;

/**
 * 练习：创建两个分线程，其中一个遍历100以内的偶数，另一个遍历100以内的奇数
 *
 *
 * @anthor shkstart
 * @create 2021-11-0211:48
 */
public class ThreadDemo {
    public static void main(String[] args) {
  /*  MyThread1 mythread1 = new MyThread1();
    MyThread2 mythread2 = new MyThread2();
    mythread1.start();
    mythread2.start();
  */
  //创建Thread类的匿名子类的方式
        new Thread()
        {
            @Override
            public void run()
            {
                super.run();
                for(int i = 0;i < 100; i++)
                {
                    if(i%2 == 0)
                    {
                        System.out.println(Thread.currentThread().getName()+"这是偶数");
                    }
                }
            }
        }.start();
        new Thread()
        {
            @Override
            public void run()
            {
                super.run();
                for(int i = 0; i < 100;i++)
                {
                    if(i%2!=0)
                    {
                        System.out.println(Thread.currentThread().getName()+"这是奇数");
                    }
                }
            }
        }.start();
    }
}

注意线程的方法名称的调用方式：Thread.currentThread().getName()

15.线程的常用方法

package com.atguigu.java;

/**
 * 测试Thread之中常用的方法：
 * 1.start（）：启动当前线程，调用当前线程的run（）方法
 * 2.run（）：通常需要重写Thread类中的方法，将创建线程的操作声明在此方法中
 * 3.currentThread（）：静态方法，返回当前代码的线程
 * 4.getName（）：获取当前线程的名字
 * 5.setName（）；设置当前线程的名字
 * @anthor shkstart
 * @create 2021-11-0214:20
 */
class HelloThread extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {
                System.out.println(Thread.currentThread().getName() + ":" + i);//默认是Thread - 0
            }
        }
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread();
        h1.setName("线程1");
        h1.start();
        //给主线程进行一个命名
        Thread.currentThread().setName("主线程");
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {
                System.out.println(Thread.currentThread().getName() + ":" + i);//默认是Thread - 0
            }
        }
    }
}

初始化线程的时候直接起名。

package com.atguigu.java;

/**
 * 测试Thread之中常用的方法：
 * 1.start（）：启动当前线程，调用当前线程的run（）方法
 * 2.run（）：通常需要重写Thread类中的方法，将创建线程的操作声明在此方法中
 * 3.currentThread（）：静态方法，返回当前代码的线程
 * 4.getName（）：获取当前线程的名字
 * 5.setName（）；设置当前线程的名字
 * @anthor shkstart
 * @create 2021-11-0214:20
 */
class HelloThread extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {
                System.out.println(Thread.currentThread().getName() + ":" + i);//默认是Thread - 0
            }
        }
    }
    public HelloThread(String name)
    {
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("初始线程");
        //h1.setName("线程1");
        h1.start();
        //给主线程进行一个命名
        Thread.currentThread().setName("主线程");
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {
                System.out.println(Thread.currentThread().getName() + ":" + i);//默认是Thread - 0
            }
        }
    }
}

yield（）的含义是释放当前线程的情况----“我扔了，我又拿到了，就不给你，呵呵”
join（）的含义是在线程A中调用线程B的方法，当线程A进入到阻塞状态的时候，直到线程B完全执行完以后，线程A才结束阻塞状态---中断。
stop（）已过时。当执行此方法的时候，强制结束当前线程。
sleep（Long millitime）：

package com.atguigu.java;

/**
 * 测试Thread之中常用的方法：
 * 1.start（）：启动当前线程，调用当前线程的run（）方法
 * 2.run（）：通常需要重写Thread类中的方法，将创建线程的操作声明在此方法中
 * 3.currentThread（）：静态方法，返回当前代码的线程
 * 4.getName（）：获取当前线程的名字
 * 5.setName（）；设置当前线程的名字
 * 6.yield（）；释放当前CPU的执行权
 * 7.join（）：在线程A中调用线程B的方法，当线程A进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态。
 * 8.stop（）已过时。当执行此方法的时候，强制结束当前线程。
 * 9.sleep（Long millitime）：
 * @anthor shkstart
 * @create 2021-11-0214:20
 */
class HelloThread extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {//注意子类的异常不能够大于父类的异常，当父类没有异常的时候，子类是不可以进行异常的
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" + i);//默认是Thread - 0
            }
            if(i%20==0)
            {
                this.yield();//this表示当前类的对象。
                //或者改成Thread.currentThread().yield（）
            }
        }
    }
    public HelloThread(String name)
    {
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("初始线程");
        //h1.setName("线程1");
        h1.start();
        //给主线程进行一个命名
        Thread.currentThread().setName("主线程");
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {
                System.out.println(Thread.currentThread().getName() + ":" + i);//默认是Thread - 0
            }
            if(i == 20)
            {
                try {       //抛出异常，使用alt + enter
                    h1.join();//线程的里面才可以调用join（），注意，否则的话会报异常
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

加了一个isAlive（）

package com.atguigu.java;

/**
 * 测试Thread之中常用的方法：
 * 1.start（）：启动当前线程，调用当前线程的run（）方法
 * 2.run（）：通常需要重写Thread类中的方法，将创建线程的操作声明在此方法中
 * 3.currentThread（）：静态方法，返回当前代码的线程
 * 4.getName（）：获取当前线程的名字
 * 5.setName（）；设置当前线程的名字
 * 6.yield（）；释放当前CPU的执行权
 * 7.join（）：在线程A中调用线程B的方法，当线程A进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态。
 * 8.stop（）已过时。当执行此方法的时候，强制结束当前线程。
 * 9.sleep（Long millitime）：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
 * 10.isAlive（）：判断当前线程是否还是存活
 * @anthor shkstart
 * @create 2021-11-0214:20
 */
class HelloThread extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {//注意子类的异常不能够大于父类的异常，当父类没有异常的时候，子类是不可以进行异常的
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + ":" + i);//默认是Thread - 0
            }
            if(i%20==0)
            {
                this.yield();//this表示当前类的对象。
                //或者改成Thread.currentThread().yield（）
            }
        }
    }
    public HelloThread(String name)
    {
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("初始线程");
        //h1.setName("线程1");
        h1.start();
        //给主线程进行一个命名
        Thread.currentThread().setName("主线程");
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {
                System.out.println(Thread.currentThread().getName() + ":" + i);//默认是Thread - 0
            }
            if(i == 20)
            {
                try {       //抛出异常，使用alt + enter
                    h1.join();//线程的里面才可以调用join（），注意，否则的话会报异常
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(h1.isAlive());//判断线程是否还存活
    }
}

16.线程的优先级设置

并不是说分线程的优先级比较高，就是完全执行完分线程，然后才执行主线程。

package com.atguigu.java;

/**
 * 测试Thread之中常用的方法：
 * 1.start（）：启动当前线程，调用当前线程的run（）方法
 * 2.run（）：通常需要重写Thread类中的方法，将创建线程的操作声明在此方法中
 * 3.currentThread（）：静态方法，返回当前代码的线程
 * 4.getName（）：获取当前线程的名字
 * 5.setName（）；设置当前线程的名字
 * 6.yield（）；释放当前CPU的执行权
 * 7.join（）：在线程A中调用线程B的方法，当线程A进入阻塞状态，直到线程B完全执行完以后，线程A才结束阻塞状态。
 * 8.stop（）已过时。当执行此方法的时候，强制结束当前线程。
 * 9.sleep（Long millitime）：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒时间内，当前线程是阻塞状态。
 * 10.isAlive（）：判断当前线程是否还是存活
 *
 * 线程的优先级
 * 1.
 * MAX_PRIORITY：10
 * MIN_PRIORITY：1
 * NORM_PRIORITY：5
 * 2.如何获取和设置当前线程的优先级
 * getPriority（）：获取线程的优先级
 * setPriority（int p）：设置线程的优先级
 * 说明：‘高优先级线程要抢占低优先级的执行权。但是只是从概率上讲，高优先级的线程高概率的情况下被执行。并不是意味着只有当高优先级的线程执行完以后，低优先级的线程才执行。
 * 
 * @anthor shkstart
 * @create 2021-11-0214:20
 */
class HelloThread extends Thread
{
    @Override
    public void run() {
        super.run();
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {//注意子类的异常不能够大于父类的异常，当父类没有异常的时候，子类是不可以进行异常的
           /*     try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                */
                System.out.println(Thread.currentThread().getName() + ":" + i +":"+ Thread.currentThread().getPriority());//默认是Thread - 0
            }
            if(i%20==0)
            {
                this.yield();//this表示当前类的对象。
                //或者改成Thread.currentThread().yield（）
            }
        }
    }
    public HelloThread(String name)
    {
        super(name);
    }
}
public class ThreadMethodTest {
    public static void main(String[] args) {
        HelloThread h1 = new HelloThread("初始线程");
        //h1.setName("线程1");
        //设置分线程的优先级
        h1.setPriority(Thread.MAX_PRIORITY);
        h1.start();
        //给主线程进行一个命名
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for(int i = 0;i < 100;i++)
        {
            if(i%2==0)
            {
                System.out.println(Thread.currentThread().getName() + ":" + i + ":"+Thread.currentThread().getPriority());//默认是Thread - 0
            }

        }
        System.out.println(h1.isAlive());//判断线程是否还存活
    }
}

17.例题：继承Thread方式，多窗口卖票

RGB三原色：0-255

package com.atshangguigu.java;

/**
 * 例子：创建三个C窗口卖票，总票数是100张
 * 存在线程安全问题，有待解决。
 * @anthor shkstart
 * @create 2021-11-0216:01
 */
class Window extends Thread
{
   private static int ticket = 100;//共享同一个静态变量，暂时先忽略三个100

    @Override
    public void run() {
        while(true)
        {
            if(ticket > 0)
            {
                System.out.println(Thread.currentThread().getName()+"：卖号，票号是："+ticket);
                ticket --;
            }
            else
            {
                break;
            }

        }
    }
}
public class WindowTest {
    public static void main(String[] args) {
        Window t1 = new Window();
        Window t2 = new Window();
        Window t3 = new Window();
        t1.setName("窗口1");
        t2.setName("窗口2");
        t3.setName("窗口3");
        t1.start();
        t2.start();
        t2.start();

    }
}

18.创建多线程方式二：实现Runnble接口

方式二创建线程的方式：

package com.atshangguigu.java;

/**
 * 创建多线程的实现方式二：实现Runnable接口
 * 1.创建实现一个Runnable接口类
 * 2.实现类去实现Runnnable中的抽象方法：run（）
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
 * 5.通过Thread类的对象，调用start（）的方法。
 * @anthor shkstart
 * @create 2021-11-0216:22
 */
//1.创建一个实现Runnable接口的类
class MThread implements Runnable
{
    //2.实现类去实现Runnable中的抽象方法：run（）
    @Override
    public void run() {
        for(int i = 0; i<100;i++)
        {
            if(i%2 == 0 )
            {
                System.out.println(Thread.currentThread().getName() +":"+ i);
            }
        }

    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5.通过Thread类的对象调用start（）：1.启动线程 2.调用当前线程的run（）----调用了Runnable类型的target的run（）方法。
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

19.例题：实现Runnable方式，多窗口卖票

package com.atshangguigu.java;

/**
 * 例子：创建三个窗口卖票，总票数是100，使用Runnable接口的方式
 * @anthor shkstart
 * @create 2021-11-0216:48
 */
class Window1 implements Runnable
{
    public  int ticket = 100;
    @Override
    public void run() {
        while (true) {
            if (ticket > 0) {
                System.out.println(Thread.currentThread().getName() + "卖出的票是" + ticket);
                ticket--;
            } else {
                break;
            }
        }
    }
}
public class WindowsTest1 {
    public static void main(String[] args) {
        Window1 mThread1 = new Window1();//共用100张票
        Thread t1 = new Thread(mThread1);
        t1.setName("线程1");
        t1.start();
        
        Thread t2 = new Thread(mThread1);
        t2.setName("线程2");
        t2.start();

        Thread t3 = new Thread(mThread1);
        t3.setName("线程3");
        t3.start();
    }
}

20.两种创建方式的对比

package com.atshangguigu.java;

/**
 * 创建多线程的实现方式二：实现Runnable接口
 * 1.创建实现一个Runnable接口类
 * 2.实现类去实现Runnnable中的抽象方法：run（）
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象。
 * 5.通过Thread类的对象，调用start（）的方法。
 *
 * 比较线程的两种方式：
 * 其一：在继承的角度而言，第二种方式比较好
 * 其二：在共享的角度而言，第二种方式比较好
 * 开发中：优先选择：实现Runnable接口的方式
 * 原因：1.实现的方式没有类的单继承性的局限性
 *      2.实现的方式更适合处理多个线程有共享数据的情况
 * 联系：Thread类本身也是继承了Runable，public class Thread implements Runnable
 * 相同点：两种方式都需要重写run（），将线程要执行的逻辑声明在run（）方法之中。
 *
 * @anthor shkstart
 * @create 2021-11-0216:22
 */
//1.创建一个实现Runnable接口的类
class MThread implements Runnable
{
    //2.实现类去实现Runnable中的抽象方法：run（）
    @Override
    public void run() {
        for(int i = 0; i<100;i++)
        {
            if(i%2 == 0 )
            {
                System.out.println(Thread.currentThread().getName() +":"+ i);
            }
        }

    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.实现类的对象
        MThread mThread = new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread t1 = new Thread(mThread);
        t1.setName("线程1");
        //5.通过Thread类的对象调用start（）：1.启动线程 2.调用当前线程的run（）----调用了Runnable类型的target的run（）方法。
        t1.start();

        //再启动一个线程，遍历100以内的偶数
        Thread t2 = new Thread(mThread);
        t2.setName("线程2");
        t2.start();
    }
}

21.每日一考

谈谈你对程序、进程、线程的理解。

程序：一段静态的代码。

进程：正在进行的程序。

线程：一个程序内部的执行路径。

代码完成继承Thread的方式创建分线程，并且遍历100以内的自然数
代码完成实现Runnable接口的方法创建分线程，并遍历100以内的自然数
对比两种创建方式

一旦使用Thread就不能继承别的类了，二者都会继承Runnable，关于共享数据的时候，优先考虑Runnable的方式

说说你对IDEA中的Project和Module的理解

对于Project的理解，对应于Eclipse之中的workspace，在IDEA之中是最大的项目。

对于Module的理解，对应于Eclipse之中的Project，在IDEA之中的相应的模块。

ASDWYang

关注

0
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
十.IDEA的使用与多线程

1.IDEA的使用与多线程的概述对于将来的学习进行了一个基本的介绍2.IDEA的卸载InerlliJ IDEA 2017.3.1版本 .metadata之中放置相应的配置------类似于config 理解config与system(是一些缓存) 卸载完软件重启一下电脑3.IDEA的介绍Eclipse->IBM 具体的介绍了一节课4.IDEA的安装...
复制链接

扫一扫

专栏目录