精华内容
下载资源
问答
  • 线程的创建1:继承Thread //线程不能用t1.run()方法 多线程的交互性 第二种方式,创建匿名子类方式 测试thread的常用方法 俩种命名方法 线程的调度/优先级 例题:卖票 创建线程2:实现...

    程序/进程/线程概念

    在这里插入图片描述
    在这里插入图片描述

    多线程的创建1:继承Thread类

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    //线程不能用t1.run()方法
    在这里插入图片描述

    多线程的交互性
    在这里插入图片描述
    第二种方式,创建匿名子类的方式
    在这里插入图片描述

    测试thread的常用方法

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    俩种命名方法
    在这里插入图片描述
    在这里插入图片描述

    线程的调度/优先级

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    例题:卖票在这里插入图片描述

    在这里插入图片描述

    在这里插入图片描述

    创建多线程2:实现runnable接口

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    同上卖票例题

    在这里插入图片描述
    在这里插入图片描述

    一个对象放到三个构造器中,三个线程用的同一个new window1(),自然ticket是同一个了

    创建线程两种方式的比较和联系

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 对象流 序列化: Serialiaze 将...java中要支持序列化反序列化,需要实现接口Serializable(标记接口) seriaVersionUID序列化版本(序列号) 当对class做修改时,seriaVersionUID就会变动,反序列化时就会报异常,可以把

    对象流

    • 序列化: Serialiaze 将java对象转换为二进制流ObjectOutputStream .writeObject(java对象)
    • 反序列化: 二进制流还原java对象ObjectInputStream .readObject() --> java对象

    java中要支持序列化和反序列化,需要实现接口Serializable(标记接口)

    seriaVersionUID序列化版本(序列号) 当对class类做修改时,seriaVersionUID就会变动,反序列化时就会报异常,可以把serialVersionUID固定,这样就不会出现异常了

    class User implements Serializable{
        private static final long serivalVersionUID = 1L;//固定序列化版本
        String username;
        transient String pass;//瞬态的 
    }
    

    transient关键字修饰的成员变量是瞬时的

    存储多个对象,读取的解决方法1

    while(true){
        try{
            Object obj = ois.readObject();
            //如果出现了 EOFException 表示读到了对象流的末尾,就该退出循环
        }catch(EOFException e){
            break;
        }
    }
    

    解决方法2

    • 把多个对象存入集合,把集合作为整体写入对象流
    • 将来读取时只需要读一次,读到的是集合

    Properties

    Properties是专门用于读取和写入*.properties文件的类

    //由于实现了Map接口所以它的文件内部都是键值对
    key=value
    
    classDiagram
    Map <-- HashMap
    Map <-- TreeMap
    Map <-- LinkedHashMap
    Map <-- Hashtable
    Hashtable <|-- Properties
    

    Hashtable是线程安全

    HashMap不是线程安全的

    Properties特有方法,特点是该类的键和值都被当做字符串

    • setProperty(String key,String value) : 添加 或修改
    • getProperty(String key) : 根据键找到对应的值 返回String value
    • stringPropertyNames() : 返回 Set 获取所有的键集合
    • load() 加载 (读取) *.properties文件的内容
      • load不会自动关流,需要手动关流
      • load既支持字节流,也支持字符流
    • store() 存储 (写入)把集合内容写到*.properties文件中
      • 既支持字节流,也支持字符流
      • store 第二个参数,表示properties中的注释信息

    *.properties文件注释的格式

    #注释内容 , 一般使用英文注解,
    

    *.properties 文件一般用作"配置文件",将来存储容易改变的信息,它不会影响java代码

    • 数据库的用户名
    • 数据库密码

    并行和并发

    • 进程 : 一个程序处于运行状态,就可以成为一个进程

    • 线程 : 一个进程是由一到多个线程组成, (java进程就是由main线程与垃圾回收线程

    • 它们都可以并行或并发的运行

    • 并行 : 多核cpu多个核同时运行代码

    • 并发 : 单核cpu单个核轮流执行多个代码片段

      • 宏观上,由于cpu在不同程序之间切换速度很快,造成"同时"效果
      • 微观上,cpu都是在交替执行的

    创建线程

    创建线程的三种方法
    • Thread : 继承Thread类 重写父类中的 run方法 (Thread类也是实现了Runnable接口的)
    • Runnable : 实现Runnable接口重写接口中的抽象方法
    • FutrueTask + Callable : 实现Callable 接口重写 call 方法 (唯一一个有返回值的线程)
    才艺展示
    //Thread 方法创建并启动线程
    class MyThread extends Thread{
        //重写父类run方法
        public void run(){
            //该线程要执行的代码
        }
    }
    new MyThread().start() //启动线程
        
    
    //Runnable 方法创建并启动线程
    class MyRunnable implements Runnable{
        public void run(){
            //此线程要执行的代码
        }
    }
    new Thread(new Runnable()).start();//启动线程
    //以上代码可以简化为匿名内部的方式
    new Thread(new Runnable(){
        public void run(){
            //要执行的线程任务
        }
    }).start();//创建并启动线程
    //由于Runnable是函数式接口所以可以简化为Lambda表达式
    new Threa(()->{
        //线程要执行的任务
    }).start();//创建并启动线程
    
    
    //FutureTask + Callable
    class MyTask implements Callable<结果类型>{
        public 结果类型 call(){
            //此线程要执行的代码
        }
    }
    //FutrueTask用来接收Callable任务的返回结果
    FutureTask task = new FutureTask(new MyTask());
    //创建并启动线程
    new Thread(task).start();
    //获取该线程的返回值
    结果类型 result = task.get();//等待线程运行结束,获取结果
    
    三种创建线程的对比
    • Runnable : 扩展性好,更灵活,可以配合Lambda用,配合线程池
    • Callable : 特点与Runnable一样,多一个返回结果
    • 继承 Thread : 不能配合线程池使用

    线程api

    线程名称默认格式 : Thread-编号 ( 名称可以自定义方便调试)

    //	使用 Runnable 方法创建线程并 自定义名字 
    new  Thread(()->{线程要执行的代码}, "线程名称");
    

    Thread.currentThread() : 得到当前线程对象

    Thread.sleep(long 毫秒值) : 让当前线程不执行代码,让出cpu使用权,等休眠时间到了,在恢复运行

    线程子类重写父类方法时不能抛出比父类 多 的异常
    优先级相关方法

    优先级返回( 1 ~ 10 )

    • setPriority(优先级) : 给予系统提示优先级 数值越大越有几率优先被执行
    • getPriority(); 返回此线程的优先级

    此处设置的优先级只是给系统的提示,至于系统是否采纳取决与系统,main线程的优先级是5

    垃圾回收线程的优先级最低

    守护线程 (垃圾回收线程)
    • 守护线程会在其他线程结束后立刻结束
    • 正常线程,必须将自身的代码全部运行完才会结束
    • main属于正常线程,垃圾回收线程属于守护线程
    • setDeamon(true) : 将当前线程设置为守护线程
    展开全文
  • 从实现方式来分可以分为两:继承实现和接口实现,相较于继承,实现接口避免了单继承局限性,所以较为常用。实现Runnable接口方式,更加符合面向对象,线程分为两部分,一部分线程对象,一部分线程任务。继承...

    Java 继承Thread 实现Runnable接口和实现Callable接口创建线程的区别

    mycsdn多线程Java多线程

    从实现方式来分可以分为两类:继承实现和接口实现,相较于继承,实现接口避免了单继承的局限性,所以较为常用。实现Runnable接口的方式,更加的符合面向对象,线程分为两部分,一部分线程对象,一部分线程任务。继承Thread类,线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象,既是线程对象,有又有线程任务。实现runnable接口,将线程任务单独分离出来封装成对象,类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。

    从功能上来说 Callable功能更加强大。无论时继承Thread类还是实现Runnable接口都是通过重写run方法,将要执行的代码放在run方法体内,而run方法是没有返回值的,Callable与Runnable的功能大致相似,Callable使用call方法,但是call()方法有返回值,call()方法还可抛出异常。

    在这里插入图片描述在这里插入图片描述

    Callable 和 Future接口的区别:

    • Callable规定的方法是call(),而Runnable规定的方法是run().
    • Callable的任务执行后可返回值,而Runnable的任务是不能返回值的。
    • call()方法可抛出异常,而run()方法是不能抛出异常的。
    • 运行Callable任务可拿到一个Future对象, Future表示异步计算的结果。
    • 它提供了检查计算是否完成的方法,以等待计算的完成,并检索计算的结果。
    • 通过Future对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果。
    展开全文
  • 在java中一般比较常用的创建线程的方式有三种: 1.Thread class --------&gt;继承Thread 2.Runnable接口 --------&gt;实现Runnable接口 3.callable接口 --------&gt;实现callable接口 接下来一一...

    在java中一般比较常用的创建线程的方式有三种:

    1.Thread class     -------->继承Thread类

    2.Runnable接口   -------->实现Runnable接口

    3.callable接口      -------->实现callable接口

    接下来一一介绍和对比

    -------------------------------------------继承Thread类----------------------------------------------------

    创建线程的步骤如下:

    1.创建线程:先继承Thread类再重写run方法

    2.启动线程:创建子类对象调用start方法

    package com.liu.threa;
    
    public class StartThread extends Thread{
    
    	/**
    	 * 新线程的入口点,会执行此线程的run方法
    	 */
    	@Override
    		public void run() {
    			for(int i =0 ;i<5;i++)
    			{
    				System.out.println("这是一号线程------>我很开心");
    			}
    		}
    	
    	public static void  main(String[] args) {
    		//创建子类对象
    		StartThread st = new StartThread();
    		//子类对象调用start()启动,开启一个新的线程
    		st.start();
    	}
    }

    -----------------------------------------实现Runnable接口-------------------------------------------------

    创建线程步骤如下:

    1、实现Runnable接口并重写run()

    2、创建实现类对象并调用Thread start

    要注意的是实现类对象是使用代理对象去启动线程,这就要涉及到静态代理设计模式。

    推荐使用实现Runnable接口这个方法,因为java里面有单继承的局限性,为了避免这种局限性多使用接口。

    package com.liu.threa;
    
    
    public class StartRun implements Runnable{//实现Runnable接口
    	/**
    	 * 线程入口点,重写run()
    	 */
    	@Override
    	public void run() {
    		for(int i =0 ;i<10;i++)
    		{
    			System.out.println("我要跳舞");
    		}
    	}
    	
    	public static void  main(String[] args) {
    		/*
    		//创建子类对象
    		StartThread st = new StartThread();
    		//创建代理对象
    		Thread m = new Thread(st);
    		//用代理对象启动
    		m.start();
    		*/
    		//对象只是用一次,可以使用匿名
    		//new Thread(new StartThread()).start();
    		
    
            //主线程
    		for(int i =0 ;i<5;i++)
    		{
    			System.out.println("我要唱歌");
    		}
    	}
    }

    ------------------------------------实现callable接口--------------------------------------------------- 

    创建线程步骤如下:

    1.实现Callable接口,重写call(),创建对象

    2.创建执行服务

    3.提交执行

    4.获取结果

    5.关闭服务

    package com.liu.threa;
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    import java.util.concurrent.Future;
    
    public class Call implements Callable<Boolean>{//实现Callable接口
    	
    	//重写call()方法
    	@Override
    	public Boolean call() throws Exception {
    		for(int i =0;i<5;i++) {
    			System.out.println("海,我来了!");
    		}
    		return true;
    	}
    	
    	
    	public static void main(String[] args) throws InterruptedException, ExecutionException {
    		Call cd = new Call();
    		//创建执行服务
    		ExecutorService ser = Executors.newFixedThreadPool(3);
    		//提交执行
    		Future<Boolean> result = ser.submit(cd);
    
    		
    		// 此for循环主线程执行
    		//--------------------------------------
    		for(int i =0;i<5;i++) {
    			System.out.println("风,我来了");
    		}
    		//--------------------------------------
    		
    		//获取结果
    		boolean r1 = result.get();
    		//关闭服务
    		ser.shutdown();
    		
    		
    	}
    
    	
    }
    

     

                                                                           

     

     

    展开全文
  • Thread(Runnable target):指定创建线程的目标对象,它实现了Runnable接口run方法 Thread(Runnable target, String name):创建新Thread对象 二、Thread类的有关方法 start():启动当前线程;调用当前线程...
  • 1、线程的创建线程的创建可以通过两种方式,第一种是 Thread,第二种是 Runnable接口:继承 Thread ,覆盖 run()实现 Runnable 接口,实现 run()然后线程启用是通过 start() 方法,它会自动调用 run() 方法,...
  • 在理解创建线程之前,我们应该了解下面程序,进程线程基本概念: 程序:是为完成特定任务,用某种语言编写一组指令集合,既**一段静态代码**,可以理解成是存储在硬盘中代码,没有加载到内存中。 进程:...
  • 实现 Runnable 接口3.CallableFuture实现有返回结果线程基于线程池方式二、4种线程池1.newCachedThreadPool2.newFixedThreadPool3.newScheduledThreadPool4.newSingleThreadExecutor三、线程生命周期(状态)...
  • 线程的创建 写一个去继承Thread,重写run()方法 写一个去实现Runable接口 public class MyThread extends Thread { @Override public void run() { for (int i=1;i<=100;i++){ System.out.println.....
  • 线程基础 一、基本概念 进程是执行程序依次执行过程...常见线程有三种方式:继承Thread、实现Runnable接口、实现Callable接口 1、继承Thread 步骤: 自定义线程类继承Thread 重写run()方法,编写线程执行...
  • 匿名类创建线程

    2018-04-13 17:21:27
    我们常用Thread类和Runnable接口创建线程,重写run()方法,启动线程......但是有些麻烦,匿名类创建线程就比较简洁方便了,而匿名类创建线程也分为两种(1)继承Thread类匿名类public class Test1 { public static ...
  • 一、线程 线程: 进程内部一个独立执行单元(通向CPU一条路径.) 1. Thread: 常用方法: Thread.currentThread().getName(); 获取当前线程名称.... 使用继承类的方式创建线程: a.创建一个Threa...
  • 创建线程 1.1 三种方式 1.1.1 创建 继承Thread:线程代码存放Thread子类run方法中。 实现Runnable:线程代码存在接口的子类run方法。 创建线程池   1.1.2 区别 源码方面区别:  继承Thread : 由于子类...
  • 文章目录线程程序、进程、线程概念线程进程关系多线程概念创建线程继承Thread实现Runnable接口图解多线程原理创建线程两种方式区别Thread方法构造方法常用方法线程优先级概述线程优先级设置 ...
  • Java有三种创建线程的方式,分别是继承Thread、实现Runable接口和使用线程池。前两种最常用。最后一种后期补充学习。1、继承Thread(1)定义集成Thread,并重写父类run()方法,方法里内容就是线程所要...
  • Java中创建线程的方式

    2020-04-01 20:32:41
    目录 并发并行 进程与线程 线程调度方式 主线程、单线程 单线程程序执行原理 ...通过创建Thread类的子类创建多线程 ...通过匿名内部类的方式创建线程 并发并行 并发:同一时间段发生 并行...
  • 创建线程相信大家都很熟悉,常用的就是继承Thread类和实现Runnable接口。 今天学习第三种方法,Callable接口和Future 来创建线程。 Callable类似于Runnable接口,但是Callable功能强于Runnable,它有返回值,线程...
  • 1.线程创建的方式常用有两种 1. 继承 Thread 类创建线程 2. 实现 Runnable 接口创建线程 2.Thread Runnable的区别 ...Thread本身是实现了 Runnable 接口的类。我们知道“一个类只能有一个父类,但...
  • Thread类和Runnable接口介绍: 进程创建: Thread介绍: Thread的常用方法: Runnable接口: 线程创建: 通过Thread类创建线程: 测试代码1: package com.imooc.thread; //创建一个新线程 ...
  • 创建线程的方式: 方法一: 自定义线程继承Thread 重写run(),编写线程执行体 创建线程对象,调用start方法启动线程。 注意:线程开启不一定立即执行,由CPU调度执行。 方法二: 定义一个实现Runnable...
  • 创建执行线程方法一:将继承Thread,重写Thread类的run方法。接下来就可以分配并启动该子类实例。 具体步骤: 继承Thread 重写run方法 将执行代码写在run方法中 创建Thread类的子类对象 使用start方法...
  • Java 创建线程的方法

    2013-01-29 19:08:55
    在Java中创建线程有两种方法:继承Thread类和实现Runnable接口。  一、继承Thread类创建线程类(Thread类已经实现了Runnable接口)  1、Thread类的构造方法有8个,但常用的只有4个,分别为:    Thread...
  • 在Java中创建线程有两种方法:继承Thread类和实现Runnable接口。 一、继承Thread类创建线程类(Thread类已经实现了Runnable接口) 1、Thread类的构造方法有8个,但常用的只有4个,分别为: Thread类中的两个最...
  • 线程常用方法 线程创建方式 1.继承Thread 2.实现Runnable接口 3.实现callable接口 callable 创建有返回值线程 /** * @author zp * @Description: 创建可返回结果线程 * 继承Runnable接口 或者 实现...
  • 如何创建线程

    2017-05-22 10:39:40
    有两种方式来创建一个线程...Thread提供构造函数方法来创建和执行线程的操作.Thread扩展了Object并实现了Runnable接口常用的Thread构造函数: Thread()Thread(String name)Thread(Ru
  • 1)继承Thread类创建线程 2)实现Runnable接口创建线程 3)使用CallableFuture创建线程 12 都是实现runable接口的方法。方法1中继承thread,其实thread也是实现了runable接口。在不谈第三种情况下还是...
  • 创建线程学习笔记

    2020-11-26 20:49:36
    创建线程学习笔记 ​ 进程是一个正在运行的程序,比如:typeroa、...创建线程常用的方式有两种: 1.继承Thread,重写run方法 该方式线程中的任务不需要手动调用,而是通过start方法在创建并开启线程后自动调用
  • 1:继承Thread实现run()方法。...3:实现Callable接口,实现call方法(相比与run方法,此方法带有返回值),创建FutureTask实例,新建线程传入参数: 4:线程池(常用) 线程池接口Excute继承关系 ...
  • 线程的创建方式一:继承于Thread方式二:实现Runnable接口创建Thread匿名子类方式2. 线程的使用Thread类的常用方法线程的调度线程的优先级线程的分类 一、基本概念 程序(program):是为完成特定任务、用某种...
  • 文章目录多线程一、进程和线程二、线程创建1、继承Thread1)创建自定义线程类,重写run方法2)测试创建自定义线程,调用其start方法来开启线程2、实现Runable接口1)创建自定义实现Runable接口2)测试,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 509
精华内容 203
关键字:

创建线程常用的类和接口