精华内容
下载资源
问答
  • java自定义线程类继承Thread与实现Runnale的区别 实例: 继承Thread线程类 public class MyThread extends Thread{ @Override public void run(){ System.out.println("这是自定义线程类继承Thread"); } } 实例: ...

    java自定义线程类继承Thread与实现Runnale的区别

    实例:  继承Thread线程类
    public class MyThread extends Thread{
        @Override
        public void run(){
            System.out.println("这是自定义线程类继承Thread");
        }
    }
    实例: 实现 Runnable接口
    public class MyThread implements Runnable{
    	@Override
        public void run(){
        	System.out.println("自定义线程类实现Runnable接口");
        }
    }
    
    区别:
    	1) 创建对象的方式不同
    		a. 继承Thread的类创建对象
    			MyThread mt1 = new MyThread(); 
    			MyThread mt2 = new MyThread(); 
    			MyThread mt3 = new MyThread(); 
    		b. 实现Runnable接口的类创建对象
    			MyThread mt = new MyThread();
    			Thread t1 = new Thread(mt);
    			Thread t2 = new Thread(mt);
    			Thread t3 = new Thread(mt);
    	2) 如果自定义类中需要使用成员变量, 继承类每创建一个对象, 成员变量就是独立的, 当需要多线程同时访问该成员变量的时候, 成员变量就会变成多个, 就会出现线程安全问题, 所以就需要用 static 修饰成员变量, 而实现接口的类, 需要创建对象, 并将的对象作为参数传递给Thread创建线程对象, 才能独立启动线程 , 根据源码, 线程会去执行自定义类的run()方法, 多线程访问时, 访问的是同一个对象的成员变量, run()方法, 所以成员变量不需要用static修饰
    

    在这里插入图片描述

    所以当多线程同时访问时, 继承Thread的类的成员变量必须用 static 修饰, 实现接口的类就可以不用 static 修饰
    	3) 线程同步, 同步方法的时候 
    		a. 如果方法被 static 修饰, 那么方法所在类的字节码对象就是同步监听对象
    		b. 方法没有 static 修饰, 那么 this(当前访问线程对象)就是同步监听对象,  如果自定义线程类采用的是继 			承Thread类, 那么同步方法时必须用 static 修饰, 每创建一个线程对象, 就要 new 一次, this 指代的			 就是不同的对象, 达不到同步的效果,  自定义类采用实现接口声明的, 同步方法就可以不用 static 修饰, 			因为通过该方式创建的线程, 访问的对象只有一个, 所以 this 是不变的
    	4) 线程同步, 使用锁机制时
    		a. 当自定义类是通过继承声明的, 那么锁必须是static修饰的成员变量
    		b. 自定义类是通过实现接口声明的时, 锁对象不需要static修饰
    
    展开全文
  • 本文给大家总结分享了下个人关于java处理自定义线程模型的一些经验和处理方法,有需要的小伙伴可以参考下
  • java自定义线程与线程方法详解

    千次阅读 2017-01-14 16:04:48
    自定义线程的创建方式:(推荐使用: 推荐使用第二种。 因为java是单继承的。)    方式一:   1. 自定义一个继承Thread.  2. 子类重写run方法,把自定义线程的任务定义在run方法上。  3. 创建thread...
     自定义线程的创建方式:(推荐使用: 推荐使用第二种。  因为java是单继承的。)
    
     
      方式一: 
      1. 自定义一个类继承Thread.
      2. 子类重写run方法,把自定义线程的任务定义在run方法上。
      3. 创建thread子类的对象,并且调用start方法开启线程。
     
      方式二:
      1. 自定义一个类去实现Runnable接口。
      2. 实现了Runnable接口的run方法, 把自定义线程的任务定义在run方法上。
      3. 创建Runnable实现类的对象。
      4. 创建Thread对象,并且把Runnable实现类对象作为参数传递进去。
      5. 调用thread对象的start方法开启线程。
     
      疑问1: Runnable实现类对象是线程对象吗?
      runnable实现类的对象并不是一个线程对象,只不过是实现了Runnable接口的对象而已。
     
    疑问2: 为什么要把Runnable实现类的对象作为参数传递给thread对象呢?作用是什么?
    作用: 是把Runnable实现类的对象的run方法作为了任务代码去执行了。


    join 加入(线程让步)  : 如果当前线程执行了join方法,那么当前线程就会让步给新加入的线程先完成任务,然后当前线程才继续的执行自己的任务。
     
    线程通讯的方法:

    wait()   执行了wait方法的线程,会让该线程进入以锁对象建立的线程池中等待。

    notify()  如果一个线程执行了notify方法,该线程会唤醒以锁对象建立的线程池中等待线程中的一个.

    notifyAll();  把所有的线程都唤醒。()
     


    线程通讯要注意的事项:
    1. wait、 notify、 notifyAll方法都是属于Object对象的方法。
    2. wait、notify方法必须要在同步代码块或者是同步函数中调用。
    3. wait、notify方法必须由锁对象调用,否则报错。

    4. 一个线程执行了wait方法会释放锁对象的。

     
    守护线程:
    守护线程(后台线程) : 当前一个java应用只剩下守护线程的时候,那么守护线程马上结束。


    守护线程应用场景:
    1. 新的软件版本下载。
     
      需求:模拟QQ在下载更新包. 
     
      守护线程要注意的事项:
      1. 所有的线程默认都不是守护线程。
     


    d.setDaemon(true); //设置一个线程为守护线程。
    System.out.println("是守护线程吗?"+d.isDaemon());  // isDaemon 判断一个线程是否为守护线程。


    停止线程要注意的实现:
    1. 我们停止一个线程一般都会配合一个变量去控制。
    2. 如果我们停止的是一个等待状态下的线程,那么需要配合interrupt方法去使用。 
    interrupt();  //强制清除一个线程的wait、 sleep状态。  可以指定清除那个线线程



    重点:当开启一个线程时,main函数中还是会边执行run方法中的语句且边执行main函数中的语句。若在线程开启下面这里用了join方法,就会先执行完线程的方法。
    展开全文
  • java自定义线程(两种方法)

    千次阅读 2017-04-12 21:10:29
    两种方式实现自定义线程 同时运行两个线程 轮流调用两个线程

    知识点总结
    java中的线程模型:一个虚拟cpu,多个线程
    static start方法:启动线程而非运行线程(仅仅告诉虚拟机,该线程已经准备完毕,cup决定线程运行的时刻)
    static sleep方法:在制定的毫秒数内让当前正在执行的线程休眠
    static yield方法:主动让出cpu,重新排队,正在执行的线程将cpu让给其他具有相同优先级的线程,自己进入就绪状态重新排队
    finnal join方法:等待该线程结束

    继承一个Thread类

    private class MyThread extends Thread{
            /**
             * <p>覆盖的run函数</p>
             * @see java.lang.Thread#run()
             * 实现run方法,安放代码逻辑
             */
            @Override
            public void run() {
                while(true){
                    lt=LocalTime.now();
                    lab_time.setText(lt.format(formatter));
                    try {
    //                  milli second 毫秒 1000 milli=1s
                        sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
        }

    缺点:无法再继承其他的类,逻辑上既有cpu,又有线程,比较混乱

    实现runnable接口

    private class MyThread2 implements Runnable{
            /**
             * <p>覆盖的run函数</p>
             * @see java.lang.Thread#run()
             * 实现run方法,安放代码逻辑
             */
            @Override
            public void run() {
                while(true){
                    lt=LocalTime.now();
                    lab_time.setText(lt.format(formatter));
                    try {
    //                  静态方法,在某些地方可能受限
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
    
            }
        }

    调用方法

    自定义线程的调用,start():启动线程而非运行线程(仅仅告诉虚拟机,该线程已经准备完毕,cup决定线程运行的时刻)

    new MyThread().start();

    交替调用两个线程

    自定义线程如下:

    private class MyThread_run implements Runnable{
            String str;
            public MyThread_run(String str) {
                this.str=str;
            }
            /**
             * <p>覆盖的run函数</p>
             * @see java.lang.Thread#run()
             * 实现run方法,安放代码逻辑
             */
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    System.out.println(Thread.currentThread()+":"+str+"  数字:"+i);
    
                    try {
    //                  静态方法,在某些地方可能受限
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
    
    
            }
        }

    调用线程,线程交替运行,sleep时间越长越容易看出效果

    Thread t1=new Thread(new MyThread_run("t1"));
            Thread t2=new Thread(new MyThread_run("t2"));
            t1.start();
            try {
                t1.sleep(1000);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
    
            t2.start();

    轮流调用两个线程

    class TwoThread3 extends Thread {
        static StringBuffer obj=new StringBuffer();
        boolean f=true;
        int mark=0;
        String num;
    
        public TwoThread3(String num) {
            this.num=num;
        }
    
        /**
         * <p>
         * 覆盖的run函数
         * </p>
         * 
         * @see java.lang.Thread#run()
         */
        @Override
        public void run() {
            synchronized (obj) {
                if (num.equals("2")&&mark==0) {
                    mark=1;
                    obj.notify();
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                for (int i = 0; i < 10; i++) {
                    obj.append(num);
                    System.out.print(num);
                    obj.notify();
                    try {
                        obj.wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
    
    
                }
            }
            save_as_file();
        }
        // 将运行结果写入文件
        public void save_as_file() {
            File file = new File("Result.txt");
            try {
                FileWriter fr = new FileWriter(file);
                BufferedWriter bw = new BufferedWriter(fr);
                bw.write(obj.toString());
                bw.close();
                fr.close();
    
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    public class TwoThread {
    
        public static void main(String[] args) {
            // 如果线程的对象不一致,则释放出来的锁不是另一个线程希望的锁,为死锁状态
            String s = "";
            new TwoThread3("2").start();
            new TwoThread3("1").start();
    
    
        }
    
    }

    运行效果:

    12121212121212121212

    写入文件的内容:

    双线程轮流调用

    展开全文
  • 重写Thread的run方法,把自定义线程的任务代码写在run方法中 创建Thread的子类对象,并且调用start方法开启线程 疑问:重写run方法的目的是什么? ​每个线程都有自己的任务代码,jvm创建的主线程的任务代码...

    自定义线程的方式一

    步骤:

    1. 自定义一个类继承Thread类
    2. 重写Thread类的run方法,把自定义线程的任务代码写在run方法中
    3. 创建Thread类的子类对象,并且调用start方法开启线程

    疑问:重写run方法的目的是什么?

    ​每个线程都有自己的任务代码,jvm创建的主线程的任务代码就是main方法中的所有代码,而自定义线程的任务代码就写在run方法中,自定义线程负责了run方法中的代码。

    注意:一个线程一旦开启,那么线程就会执行run方法中的代码,run方法千万不能直接调用,直接调用run方法就相当与调用了一个普通的方法而并没有开启新的线程。

    public class Demo1 extends Thread {
    	@Override // 把自定义线程的任务代码写在run方法中。
    	public void run() {
    		for(int i = 0;i < 100;i ++) {
    			System.out.println("自定义线程:" + i);
    		}
    	}
    	
    	public static void main(String[] args) {
    		Demo1 d = new Demo1(); // 创建自定义的线程对象
    		d.start(); // 调用start方法启动线程
    		for(int i = 0;i < 100;i ++) {
    			System.out.println("主线程:" + i);
    		}
    	}
    }
    

    自定义线程的方式二

    步骤:

    1. 自定义一个类实现Runnable接口
    2. 实现Runnable接口的run方法,把自定义线程的任务代码写在run方法上
    3. 创建Runnable实现类的对象
    4. 创建Thread类的对象,并且把Runnable实现类的对象作为实参传递
    5. 调用Thread对象的start方法开启一个线程

    问题1:请问Runnable实现类的对象是线程对象吗?

    Runnable实现类的对象不是线程对象,只不过是实现Runnable接口的类的对象而已。只有Thread类或者Thread类的子类才是线程对象

    问题2:为什么要把Runnable实现类的对象作为实参传递给Thread对象呢?作用是什么?

    作用就是把Runnable实现类的对象的run方法作为线程的任务代码去执行

    public class Demo2 implements Runnable { // 1、自定义一个类实现Runnable接口
    	/**
    	* 2、实现Runnable接口的run方法,把自定义线程的任务代码写在run方法上
    	*/
    	@Override
    	public void run() {
    		System.out.println("this:" + this); // (this表示的是Runnable接口的实现类对象)
    		System.out.println("当前线程:" + Thread.currentThread().getName()); // 狗娃
    		for(int i = 0;i < 100;i ++){
    			System.out.println(Thread.currentThread().getName() + ":" + i);
    		}
    	}
    	
    	public static void main(String[] args) {
    		// 3、创建Runnable实现类的对象
    		Demo2 d = new Demo2();
    		// 4、创建Thread类的对象,并且把Runnable实现类的对象作为实参传递
    		Thread thread = new Thread(d, "狗娃"); // 创建了一个线程对象,并将其名字赋初值。
    		// 5、调用Thread对象的start方法开启一个线程
    		thread.start();
    		for(int i = 0;i < 100;i ++) {
    			System.out.println(Thread.currentThread().getName() + ":" + i);
    		}
    	}
    }
    
    展开全文
  • import java.util.concurrent.ThreadFactory; import java.util.concurrent.atomic.AtomicInteger;... * 描述:线程的Factory,以便自定义线程名  *  * @author Cache John  *  */ public cl
  • 13.6 Thread类自定义线程类

    千次阅读 2016-11-15 19:57:19
    /* * * 线程: * 多线程: * 一个java程序只是有两个线程: * 一个是主线程负责main方法代码执行,一个是垃圾回收器...自定义一个继承 Thread * 2.重写Threadrun方法。右击--source--override *
  • /**自定义类MyThread 实现Runnable接口,主函数创建5个线程,自定义线程类的构造函数输出 创建线程X * run方法内统计每个线程 一共6次 * 用hashmap 集合 统计每个线程的次数,创建一个集合。 *
  • 主要介绍了JAVA 自定义线程池的最大线程数设置方法,文中示例代码非常详细,供大家参考和学习,感兴趣的朋友可以了解下
  • Java线程- Thread 与 Runnable
  • /**自定义类MyThread 实现Runnable接口,主函数创建5个线程,自定义线程类的构造函数输出 创建线程X * run方法内统计每个线程 一共6次 * 用hashmap 集合 统计每个线程的次数,创建一个集合。 *
  • /**自定义类MyThread 实现Runnable接口,主函数创建5个线程,自定义线程类的构造函数输出 创建线程X * run方法内统计每个线程 一共6次 * 用hashmap 集合 统计每个线程的次数,创建五个集合。 *
  • 自定义线程Runnable接口

    千次阅读 2017-03-15 18:37:57
    重写Thread的run方法,把自定义线程的任务代码写在run方法上。  3.创建Thread的子类对象,并且调用start()方法启动一个线程。  注意:千万不要直接调用run()方法,调用start()方法的时候线程就会启动,线程...
  • 本篇文章主要介绍了java线程学习笔记之自定义线程池 ,小编觉得挺不错的,现在分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java自定义线程池和线程总数控制

    千次阅读 2017-02-04 10:33:31
    池化是常见的思想,线程池是非常典型的池化的实现,《Java并发编程实战》也大篇幅去讲解了Java中的线程池。本文实现一个简单的线程池。 2 核心 【1】接口定义 public interface IThreadPool<Job extends ...
  • Callable是类似于Runnable的接口,实现Callable接口的和实现Runnable的都是可被其它线程执行的任务
  • JavaSE基础(88) 自定义线程的2种方式

    千次阅读 2018-08-27 21:59:07
    程序:存放在电脑硬盘上的命令集合。 是静态的进程:是程序运行之后,在内存中产生的数据。线程:组成进程的最小单位。 比如:进程是执行100行的代码效果,线程是1行的代码的效果 ...在自定义线程类中 覆写r...
  • Java线程:彻底搞懂线程池

    万次阅读 多人点赞 2019-07-09 19:27:00
    熟悉Java线程编程的同学都知道,当我们线程创建过多时,容易引发内存溢出,因此我们就有必要使用线程池的技术了。 目录 1 线程池的优势 2 线程池的使用 3 线程池的工作原理 4 线程池的参数 4.1 任务队列...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 274,652
精华内容 109,860
关键字:

java怎么自定义线程类

java 订阅