精华内容
下载资源
问答
  • 多线程的创建方式一:继承Thread类 1.创建一个继承于Thread类的子类 2.重写Thread中的run() 3.创建Thread类的子类的对象 4.通过此对象去调用start() 启动当前线程,调用当前线程的run() package one; public class...

    多线程的创建,方式一:继承Thread类
    1.创建一个继承于Thread类的子类
    2.重写Thread中的run()
    3.创建Thread类的子类的对象
    4.通过此对象去调用start() 启动当前线程,调用当前线程的run()

    package one;
    public class ThreadTest {
        public static void main(String[] args) {
            myThread myThread=new myThread();
            myThread.start();
        }
    }class myThread extends  Thread{
    
        @Override
        public void run() {
            for(int i=0;i<=100;i++){
                if(i%2==0){
                    System.out.println(i+" "+Thread.currentThread().getName());
                }
            }
        }
    }
    

    利用继承thread的方式,从三个窗口出售100张票,需要将票设置为static

    class Window extends Thread{
        private static int ticket =100;
        public Window(String name){
            super(name);
        }
    
        @Override
        public void run() {
            while (true){
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
    
                }else {
                    break;
    
                }
            }
        }
    }
    public class WindowsTest {
        public static void main(String[] args) {
            Window window1=new Window("窗口1" );
            Window window2=new Window("窗口2" );
            Window window3=new Window("窗口3" );
            window1.start();
            window2.start();
            window3.start();
        }
    }
    

    创建多线程的方式二:实现 Runnable接口
    1.创建一个实现了Runnable接口的类
    2.实现类去实现Runnable中的抽象方法:run()
    3.创建实例类的对象
    4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
    5.通过Thread类的对象调用start()

    比较创建线程的两种方式
    开发中优先选择实现Runnable接口的方式
    原因:1.实现的方式没有类的单继承性的局限性
    2.实现的方法更适合处理多个线程有共享数据的情况
    相同点:都需要重写run(),将线程要执行的逻辑声明在run()中

    class Mythread2 implements  Runnable{
        private int ticket=100;
        @Override
        public void run() {
            while(true){
                if(ticket>0){
                    System.out.println(Thread.currentThread().getName()+":"+ticket);
                    ticket--;
                }else
                {
                    break;
                }
    
            }
        }
    }
    public class ThreadTest2 {
        public static void main(String[] args) {
            Mythread2 mythread2=new Mythread2();
            Thread thread1=new Thread(mythread2);
            thread1.setName("线程一");
            Thread thread2=new Thread(mythread2);
            thread2.setName("线程二");
            Thread thread3=new Thread(mythread2);
            thread3.setName("线程三");
            thread1.start();
            thread2.start();
            thread3.start();
        }
    }
    

    非自己编写的代码,只作为笔记浏览,无其他用途。

    展开全文
  • 在Java中创建线程的方式有两种,第一种是直接继承Thead类,另一种是实现Runable接口。那么这两种方式孰优孰劣呢?这就是本文需要探讨的内容范畴了,看官们请仔细向下看
  • 这里写自定义目录标题多线程的创建两种创建方式的对比: 多线程的创建多线程的创建方式一:继承Thread类。 // 1.创建一个继承于Thread的子类 class MyThread extends Thread{ // 2.重写run()方法 @Override ...

    多线程的创建:

    多线程的创建方式一:继承Thread类。


    // 1.创建一个继承于Thread的子类
    class MyThread extends Thread{
        // 2.重写run()方法
        @Override
        public void run() {
            for (int i = 0; i <100 ; i++) {
                if(i % 2 == 0){
                    System.out.println(i);
                }
            }
        }
    }
    
    class ThreadTest1 {
        public static void main(String[] args) {
            // 3.创建子类对象
            MyThread t1 = new MyThread();
            // 4.调用start()方法
            t1.start();// 1.启动当前线程 2.调用run方法。
        }
    }
    
    

    运行结果:

    在这里插入图片描述
    注意事项
    1.启动线程应该调用start(),而不是调用run()。
    2.如果再启动一个线程,必须重新创建Thread子类的对象,重写该子类的run()。

    多线程的创建方式二:实现Runnable接口。

    class MThread implements Runnable{
    
        @Override
        public void run() {
            for (int i = 0; i <100 ; i++) {
                if (i % 2 == 0) {
                    System.out.println(i);
                }
    
            }
        }
    }
    public class ThreadTest2 {
        public static void main(String[] args) {
            MThread m1 = new MThread();
            Thread t1 = new Thread(m1);
            t1.start(); //调用了Runnable中的target的run();
    
        }
    }
    
    

    运行结果:

    在这里插入图片描述

    两种创建方式的对比:

    不同点:
    使用继承Thread的方式无法再让Thread子类去继承其他的类,使用Runnable接口可以有实现其他接口的方式,没有类单继承的局限性。
    相同点:
    都要重写run()。
    一般推荐使用实现Runnable接口的方法,需要共享数据时推荐此方法,例如卖票系统。

    两种创建方式实现卖票:

    // 创建三个窗口买票,总票数为100 张:使用继承Thread的方式。
     class Window1 extends Thread{
         private static int Ticket = 100;
        @Override
        public void run() {
            while (true){
                if(Ticket > 0){
                    System.out.println(getName() + ":卖票:票号为:" + Ticket);
                    Ticket--;
                }else {
                    break;
                }
            }
        }
    }
    public class ThreadTest03 {
        public static void main(String[] args) {
            Window1 w1 = new Window1();
            Window1 w2 = new Window1();
            Window1 w3 = new Window1();
            w1.setName("窗口1");
            w2.setName("窗口2");
            w3.setName("窗口3");
            w1.start();
            w2.start();
            w3.start();
    
    
        }
    
    }
    
    //创建三个窗口买票,总票数为100 张:使用实现Runaable接口的方式。
    class Window2 implements Runnable{
        private int Ticket = 100;
    
        @Override
        public void run() {
            while (true){
                if(Ticket > 0){
                    System.out.println(Thread.currentThread().getName() + "卖票:票号为:" + Ticket);
                    Ticket--;
                }else{
                    break;
                }
            }
        }
    }
    public class ThreadTest04 {
        public static void main(String[] args) {
            Window2 w1 = new Window2();
    
    
            Thread t1 = new Thread(w1);
            Thread t2 = new Thread(w1);
            Thread t3 = new Thread(w1);
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
            t1.start();
            t2.start();
            t3.start();
        }
    }
    
    
    展开全文
  • 将此线程执行操作声明在run()方法中 创建Thread类子类对象 通过此对象调用start() // 1.创建一个继承于Thread类子类 class MyThread extends Thread{ //2. 重写Thread类run() @Override public void ...

    方式一:继承于Thread类

    1. 创建一个继承于Thread类的子类
    2. 重写Thread类的run() --> 将此线程执行的操作声明在run()方法中
    3. 创建Thread类的子类的对象
    4. 通过此对象调用start()
    // 1.创建一个继承于Thread类的子类
    class MyThread extends Thread{
        //2. 重写Thread类的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 ThreadTest {
        public static void main(String[] args) {
            // 3. 创建Thread类的子类的对象
            MyThread t1 = new MyThread();
            // 4. 通过此对象调用start(): ① 启动当前线程 ② 调用当前线程的run()方法
            t1.start();
            // 问题一:我们不能通过直接调用run()的方式启动线程
    //        t1.run();
    
            // 问题二:再启动一个线程,遍历100以内偶数。不可以还让已经start()的线程去执行,会报IllegalThreadStateException
            MyThread t2 = new MyThread();
            t2.start();
    
            // 如下操作仍然是在main线程中执行的
            for (int i = 0; i < 100; i++) {
                if(i % 2 == 0){
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }
    }
    

    方式二:实现Runnable接口

    1. 创建一个实现了Runnable接口的类
    2. 实现类去实现Runnable中的抽象方法:run()
    3. 创建实现类的对象
    4. 将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
    5. 通过Thread类的对象调用start()
    // 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("线程一");
            // 5. 通过Thread类的对象调用start():① 启动当前线程 ② 调用当前线程的run() --> 调用了Runnable类型的target的run()
            t1.start();
            Thread t2 = new Thread(mThread);
            t2.setName("线程二");
            t2.start();
        }
    }
    

    两种方式的对比:

    开发中:优先选择:实现Runnable接口的方式
    原因:1. 实现的方式没类的单继承性的局限性
    2. 实现的方式更适合来处理多个线程共享数据的情况。

    联系:public class Thread implements Runnable
    相同点:两种方式都需要重写run(),将线程要执行的逻辑声明在run()中。
    目前两种方式,要想启动线程,都是调用的Thread类中的start()。

    展开全文
  • 注意:执行完start()后并不表示此对象对应的线程就一定会立即得到执行,只是表示该线程具有了可以立即被CPU执行资格,但由于想抢占CPU的线程,CPU并不一定会立即去执行此对象对应的线程。 说明个问题: 问题...

    方式一:继承Thread类的方式

    • 1.创建一个继承于Thread类的子类
    • 2.重写Thread类的run() --> 将此线程执行的操作声明在run()中
    • 3.创建Thread类的子类的对象
    • 4.通过此对象调用start()
      注意:执行完start()后并不表示此对象对应的线程就一定会立即得到执行,只是表示该线程具有了可以立即被CPU执行的资格,但由于想抢占CPU的线程很多,CPU并不一定会立即去执行此对象对应的线程。
      说明两个问题:
      问题一:我们不能通过直接调用run()的方式启动线程。
      问题二:再启动一个线程,遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
    //1. 创建一个继承于Thread类的子类
    class MyThread extends Thread {
        //2. 重写Thread类的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 ThreadTest {
        public static void main(String[] args) {
            //3. 创建Thread类的子类的对象
            MyThread t1 = new MyThread();
    
            //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
            t1.start();
            //问题一:我们不能通过直接调用run()的方式启动线程。
    //        t1.run();
    
            //问题二:再启动一个线程,遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
    //        t1.start();
            //我们需要重新创建一个线程的对象
            MyThread t2 = new MyThread();
            t2.start();
    
    
            //如下操作仍然是在main线程中执行的。
            for (int i = 0; i < 100; i++) {
                if(i % 2 == 0){
                    System.out.println(Thread.currentThread().getName() + ":" + i + "***********main()************");
                }
            }
        }
    
    }
    

    方式二:实现Runnable接口的方式

    • 1.创建一个实现了Runnable接口的类
    • 2.实现类去实现Runnable中的抽象方法:run()
    • 3.创建实现类的对象
    • 4.将此对象作为参数传递到Thread类的构造器中,创建Thread类的对象
    • 5.通过Thread类的对象调用start()
    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():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
            t1.start();
    
            //再启动一个线程,遍历100以内的偶数
            Thread t2 = new Thread(mThread);
            t2.setName("线程2");
            t2.start();
        }
    
    }
    

    两种方式的对比:

    在这里插入图片描述

    展开全文
  • 具有多线程能力计算机因有硬件支持而能够在同一时间执行多于一个线程,进而提升整体处理性能。——维基百科 简单来说,假如我们把一个线程看作一个任务,CPU就是用来执行这个任务,如果只有一个CPU,却有多个...
  • 创建多线程的第一种方式:创建Thread类的子类java.lang.Thread类:是描述线程的类,我们想要实现多线程程序,就必须继承Thread类实现步骤:1.创建Thread类的子类2.在Thread类的子类中重写Thread类中的run方法,设置...
  • 本文目录 ...经过总结,Python创建多线程主要有如下两种方法: 函数 类 接下来,我们就来揭开多线程的神秘面纱。 . 学会使用函数创建多线程 在Python3中,Python提供了一个内置模块 thre...
  • public class Test_thread { //主程序 public static void main(String[] args) throws InterruptedException { ... //第一 MyThread_test1(); System.out.println("============...
  • 1.在Thread子类覆盖run方法中编写运行代码 Thread t1 = new Thread(){ public void run() { while(true){ try { Thread.sleep(500); } catch (InterruptedException e) { e.printStackTrace(); ...
  • 线程相关概念 并行与并发 概念阶段: ...线程:线程是指进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程,一个进程中是可以有线程的,这个应用程序可以称之为线
  • * @description 多线程的创建方式一:继承于Thread类 * * * * eg: 遍历100以内的所有的偶数 * 1.创建一个继承于Thread类的子类 * 2.重写Thread类的run()方法 ---->讲此线程执行的操作声明在run()方法中 ...
  • 注意:次启动线程次调用start()方法)是不合法。 实现Runnable接口:实现Runnable接口,再重写run方法,然后将这个实现类当做参数传给Thread类,例如:Thread dog = new Thread(runn,"小狗"),创建...
  • 多线程(多线程的引入)什么是线程线程是程序执行的一条路径, 一个进程中可以包含多条线程; 多线程并发执行可以提高程序的效率, 可以同时完成多项工作。多线程(多线程并行和并发的区别)并行就是个任务同时运行,...
  • 两种方式的比较: 继承Thread优势和劣势: 优势:编写简单,如果需要访问当前线程,直接使用this即可,无需使用Thread.currentThread().getName()方法 劣势:因为已经继承了Thread,所以无法继承其他类...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,261
精华内容 1,704
关键字:

创建多线程的两种方式