精华内容
下载资源
问答
  • 使用多线程模拟多人徒步爬山 训练要点 使用任意一种方式创建线程 使用Thread.sleep()方法 设置线程休眠 需求说明 每个线程代表一个人 可设置每人爬山速度 每爬完100米显示信息 爬到终点时给出相应提示 */...
  • 第三章JAVA高级特性多线程

    千次阅读 2018-08-20 21:25:55
    多线程介绍 学习多线程之前,我们先要了解几个关于多线程有关的概念。 进程:进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。 ...
    1. 多线程介绍

    学习多线程之前,我们先要了解几个关于多线程有关的概念。

    进程:进程指正在运行的程序。确切的来说,当一个程序进入内存运行,即变成一个进程,进程是处于运行过程中的程序,并且具有一定独立功能。

    线程:线程是进程中的一个执行单元,负责当前进程中程序的执行,一个进程中至少有一个线程。一个进程中是可以有多个线程的,这个应用程序也可以称之为多线程程序。

    简而言之:一个程序运行后至少有一个进程,一个进程中可以包含多个线程

    例一:

    需求说明:张三和妻子各拥有一张银行卡和存折,可以对同一个银行账户进行存取款的操作,请使用多线程及同步方法模拟张三和妻子同时取款的过程。要求使用同步方法和同步代码块两种方式实现

    分析:定义Account类表示银行帐户      定义两个线程分别实现张三和妻子取款的操作

    package com.vp.day06.demo01;
    
    
    public class Bank implements Runnable {
        int money = 500;
    
    
        @Override
        public void run() {
            while (true) {
                if (money == 0) {
                    break;
                }
                sale();
            }
        }
    
        public synchronized void sale() {
    
            if (money > 0) {
                System.out.println(Thread.currentThread().getName() + "准备取款!");
                System.out.println(Thread.currentThread().getName() + "取款完毕!");
                money -= 100;
                try {
                    Thread.sleep(500);
                } catch (Exception e) {
                }
            } else {
                for (int i = 0; i < 5; i++) {
                    System.out.println("余额不足以支付" + Thread.currentThread().getName() + "的取款,余额为0");
                }
            }
        }
    
    
    
        private int money = 500; // 存款500
        private int num = 0; // 存款不足的次数
        @Override
        public void run() {
            for (int i = 0; i < 5; i++) { // 取款5次
                synchronized (this) {
                    if (num >= 5) {
                        break;
                    }
                    if (money > 0) { // 存款够的时候
                        System.out.println(Thread.currentThread().getName() + "准备取款");
                        System.out.println(Thread.currentThread().getName() + "完成取款");
    
                    } else if (money <= 0) { // 存款不足时
                        num++;
                        System.out.println("余额不足以支付" + Thread.currentThread().getName() + "的取款,余额为0");
                    }
                    money -= 100;
                    try {
                        Thread.sleep(500); // 模拟取款时间
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
    
    package com.vp.day06.demo01;
    
    import com.vp.day06.demo02.MyRunnablethree;
    
    /**
     * 张三和妻子各拥有一张银行卡和存折,可以对同一个银行账户进行存取款的操作,请使用多线程及同步方法模拟张三和妻子同时取款的过程。
     * 要求使用同步方法和同步代码块两种方式实现
     分析
     定义Account类表示银行帐户
     定义两个线程分别实现张三和妻子取款的操作
     */
    public class Test {
        public static void main(String[] args) {
            Bank bank =new Bank();
            Thread thread=new Thread( bank,"张三" );
            Thread thread1=new Thread( bank,"张三的妻子" );
            thread.start();
            thread1.start();
        }
    }
    

    例二:模拟多人徒步爬山

    使用多线程模拟多人徒步爬山

    训练要点

    1. 使用任意一种方式创建线程 
    2. 使用Thread.sleep()方法 

    设置线程休眠 

    需求说明

    1. 每个线程代表一个人 
    2. 可设置每人爬山速度 
    3. 每爬完100米显示信息 
    4. 爬到终点时给出相应提示 

    package com.vp.day06.demo02;
    
    /**
     *使用多线程模拟多人徒步爬山
     训练要点
     使用任意一种方式创建线程
     使用Thread.sleep()方法
     设置线程休眠
     需求说明
     每个线程代表一个人
     可设置每人爬山速度
     每爬完100米显示信息
     爬到终点时给出相应提示
    
     */
    public class MyRunnablethree extends Thread{
        private int time;
        public int num=0;
    
        public MyRunnablethree(String name, int time,int kio) {
            super(name);
            this.time = time;
            this.num=kio*1000/100;
        }
    
        @Override
        public void run() {
            while (num>0){
                try {
                    Thread.sleep(this.time);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
    
                System.out.println(Thread.currentThread().getName()+"爬完100米!");
                num--;
            }
            System.out.println(Thread.currentThread().getName()+"到达终点!");
        }
    }
    
    package com.vp.day06.demo02;
    
    /**
     * 模拟多人徒步爬山
     使用多线程模拟多人徒步爬山
     训练要点
     使用任意一种方式创建线程
     使用Thread.sleep()方法
     设置线程休眠
     需求说明
     每个线程代表一个人
     可设置每人爬山速度
     每爬完100米显示信息
     爬到终点时给出相应提示
     */
    
    public class Test {
        public static void main(String[] args) {
            MyRunnablethree aged=new MyRunnablethree("老年人",1500,1);
            MyRunnablethree youngPeopl=new MyRunnablethree("年轻人",500,1);
            System.out.println("********开始爬山********");
            aged.start();
            youngPeopl.start();
        }
    }
    

     

    展开全文
  • 第1关:顺序输出 任务描述 本关任务:利用多线程相关知识控制三个线程,依照先后顺序顺序输出。...可以参考的实训有:Java高级特性 - 多线程基础(2)常用函数 测试说明 测试输入:无; 预期输出: JavaThrea

    第1关:顺序输出
    任务描述
    本关任务:利用多线程相关知识控制三个线程,依照先后顺序顺序输出。
    相关知识(略)
    编程要求
    请仔细阅读右侧代码,在 Begin-End 区域内进行代码补充,使线程依照先后顺序依次输出JavaThread+线程名。
    提示:我们知道线程的执行结果是随机的,什么时候执行线程是看哪一个线程抢占到了CPU的资源,现在请你利用所学知识使多个线程开启之后依照先后顺序执行。
    可以参考的实训有:Java高级特性 - 多线程基础(2)常用函数
    测试说明
    测试输入:无;
    预期输出:
    JavaThreadAA
    JavaThreadBB
    JavaThreadCC
    JavaThreadAA
    JavaThreadBB
    JavaThreadCC
    JavaThreadAA
    JavaThreadBB
    JavaThreadCC
    JavaThreadAA
    JavaThreadBB
    JavaThreadCC
    JavaThreadAA
    JavaThreadBB
    JavaThreadCC
    开始你的任务吧,祝你成功!
    参考代码:

    package step1;
    public class Task {
    	public static void main(String[] args) throws Exception {
    		/********* Begin *********/
    		//在这里创建线程, 开启线程
    	 Object a = new Object();
            Object b = new Object();
            Object c = new Object();
    		MyThread ta = new MyThread("A",c,a);
    		MyThread tb = new MyThread("B",a,b);
    		MyThread tc = new MyThread("C",b,c);
    		ta.start();
    		ta.sleep(100);
    		tb.start();
    		tb.sleep(100);
    		tc.start();
    		tc.sleep(100);	
    		/********* End *********/
    	}
    }
    class MyThread extends Thread {
    	/********* Begin *********/
    	private String threadName;
    	private Object prev;
    	private Object self;
    	public MyThread(String name,Object prev,Object self){
    		this.threadName = name;
    		this.prev = prev;
    		this.self = self;
    	}
    	public void run() {
    		int count = 5;
    		while(count>0){
    			synchronized(prev){
    				synchronized(self){
    					System.out.println("Java Thread"+this.threadName+this.threadName);
    					count--;
    					self.notify();
    				}
    				try {
                        prev.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
    				}
    			}
    		}
    		System.exit(0);
    	}
    	/********* End *********/
    }
    

    第2关:售票窗口
    任务描述
    本关任务:利用多线程技术,编写一个卖票的小程序,
    相关知识(略)
    编程要求
    目前有三个窗口同时出售20张票,需要你在右侧代码中的 Begin-End 区域编写代码实现多个窗口售票的功能,具体要求如下:
    票数要使用同一个静态值;
    为保证不会出现卖出同一张票,使用java多线程同步锁(synchronized或lock)。
    解题思路:
    创建一个站台类Station,继承Thread,重写run方法,在run方法里面执行售票操作(即如果票没卖完就一直卖)!售票要使用同步锁:即有一个站台卖这张票时,其他站台要等这张票卖完!
    相关知识可以参考实训:Java高级特性 - 多线程基础(3)线程同步
    测试说明
    本关执行代码已经提前写好如下,不需要你重新编写运行代码:

    public static void main(String[] args) {
            //实例化站台对象,并为每一个站台取名字
             Station station1=new Station();
             Station station2=new Station();
             Station station3=new Station();
            // 让每一个站台对象各自开始工作
             station1.start();
             station2.start();
             station3.start();
    }
    

    测试输入:无;
    预期输出:
    卖出了第20张票
    卖出了第19张票
    卖出了第18张票
    卖出了第17张票
    卖出了第16张票
    卖出了第15张票
    卖出了第14张票
    卖出了第13张票
    卖出了第12张票
    卖出了第11张票
    卖出了第10张票
    卖出了第9张票
    卖出了第8张票
    卖出了第7张票
    卖出了第6张票
    卖出了第5张票
    卖出了第4张票
    卖出了第3张票
    卖出了第2张票
    卖出了第1张票
    票卖完了
    开始你的任务吧,祝你成功!
    参考代码:

    package step2;
    /********* Begin *********/
    //定义站台类,实现卖票的功能。
    public class Station extends Thread{	 
    	static int tick = 20; // 为了保持票数的一致,票数要静态
        static Object ob = new Object(); // 创建一个静态钥匙 值是任意的
        public void ticket() {
            System.out.println( "卖出了第" + tick + "张票");
            tick--;
        }
        public void run() {
            while (tick > 0) {
                synchronized (ob) {
                    if (tick > 0) {
                        ticket();
                    } 
                }
                if(tick == 0){
                    System.out.println("票卖完了");
                }
                try {
                    Thread.sleep(100);
                } catch (Exception e) {
                }
            }
    	}
    }
    /********* End *********/
    
    展开全文
  • java高级特性多线程

    千次阅读 2016-07-18 21:09:59
    程序–>进程 —>线程 理解何时需要多线程操作:1,程序需要执行多个任务的时候。2,程序需要实现一个等待的任务时,如等待用户输入,文件读写,网络操作,搜索等。3,程序需要后台运行的程序时。创建分线程的方式:1...

    java多线程知识点:

    1、创建分线程的方式

    2、单例模式懒汉式线程安全问题

    3、java线程同步

    4、java线程通信

    5、java的内存模型

    认识线程:

    每一个java程序都有一个隐含的主线程,即main()方法。

    程序–>进程 —>线程 理解

    何时需要多线程操作:

    1,程序需要执行多个任务的时候。
    
    2,程序需要实现一个等待的任务时,如等待用户输入,文件读写,网络操作,搜索等。
    
    3,程序需要后台运行的程序时。

    创建分线程的方式:

    1,继承Thread类,其子类重写Thread类的run()方法即可。
    
        每一个线程都是通过Thread类的run()方法来完成相应的功能,经常把run()方法的主体称为 线程体。
    
        通过子类对象的start()方法来执行当前线程。start()方法的两个作用:①启动当前线程 ②执行线程的run()方法。
    
    2,创建实现Runnable接口的类,并且实现接口中的抽象run()方法。
    
    实例化一个Rundnable接口实现类的对象,并将此对象作为参数传递给Thread类的构造器。
    
    通过Thread类对象调用strar()方法执行当前线程。
    多线程认识:JVM负责管理这些线程,这些线程将被轮流执行。使得每一个线程都有机会使用CPU资源。
    

    两种分线程创建的联系和区别:

    1public static Thread implements Runnable
    {Thread 类的本质如上实现了Runnable 接口}
    
    2,第二种分线程创建的方式如下优点:
    
    ①没有单继承的局限
    
    ②若多线程有共享数据的话,实现更加方便。

    使用Thread子类创建线程的优点:
    可以在子类中增加新的成员变量,使得线程具有某种属性,也可以在子类中新增加方法,使线程具有某种功能。但是java不支持多继承,Thread类的子类不能再拓展其他类。

    线程中的常用方法:

     * 1.start():开启线程;执行相应的run()
    
     * 2.run():分线程要执行的功能封装在run()中
    
     * 3.currentThread():获取当前正在执行的线程
    
     * 4.getName():获取当前线程的名字
    
     * 5.setName():设置当前线程的名字
    
     * 6.yield():暂时释放线程对当前cpu的占用
    
     * 7.join():在线程a中调用线程b.join()表示:当前线程a进入阻塞状态,线程b开始执行,直到线程b执行结束,线程a才继续执行。
    
     * 8.sleep(long millitimes):显示的使得当前线程睡眠指定的毫秒数。这个过程中,当前线程处于阻塞状态
    
     * 9.isAlive():当前线程是否还存活
    
     *
    
     * 10.线程的优先级:getPriority() / setPriority(int i)
    
     *   MIN_PRIORITY:1
    
     *   NORM_PRIORITY:5
    
     *   MAX_PRIORITY:10
    
     *   优先级高,并不是当前线程被首先执行完,而是被执行的概率大
    
     * 11.线程的通信: wait() / notify()  / notifyAll()

    单例模式-懒汉式线程安全及高效率的问题

    
    public Bank getInstance() {
    
    if (bank == null) {
    
         synchronized (this) {
    
              if (bank == null) {
    
                   bank = new Bank();
    
                                            }
                   }
             }
    
     return bank;
    
    }
    

    线程的生命周期:

    线程的生命周期图

    线程的同步机制:解决线程的安全问题

    出现线程安全问题的原因:

    当一个线程在操作共享数据的过程中,还没有执行结束,另外的线程就参与进来,同样的去操作共享数据,就导致了出现了线程安全的问题
    

    如何解决:

    必须让一个线程完整的操作完共享数据之后,其他的线程才可以参与进来,继续操作共享数据。

    java同步机制

    同步代码块:

    synchronized(同步监视器){

     //需要被同步的代码
    
       }
    

    同步方法:

    public synchronized void show(){

    //方法体

    }

    除了synchronized关键字之外,还可以定义一个可重入锁的变量

    private ReentrantLock lock = new ReentrantLock();

    lock.clock()

    try{

    //需要被同步的代码块

    }finally{

    lock.unlock()}

    从Java 5开始,Java提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用Lock对象充当。 Lock是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问,每次只能有一个线程对Lock对象加锁,线程开始访问共享资源之前应先获得Lock对象。 在实现线程安全的控制中,比较常用的是ReentrantLock(可重入锁),可以显式加锁、释放锁。

    说明:
    
         1.需要被同步的代码,即为操作共享数据的代码
    
         2.共享数据:多个线程共同操作的变量。
    
         3.同步监视器,俗称锁。哪个线程获取了锁,哪个线程就执行大括号中需要被执行的代码。其它的线程在外面等待。
    
    共享数据的访问权限必须是private,以保证当前线程访问数据的时候,工作主内存空间的线程不能访问和操作数据。
    
     >任何一个类的对象都能充当锁
    
     >保证线程的安全,需要所有的线程共用同一把锁!,(优先考虑this)
    

    释放锁的操作:

    1、当前线程的同步方法、同步代码块执行结束
    2、当前线程在同步代码块、同步方法中遇到break、return终止了该代码块、该方法的继续执行。
    3、当前线程在同步代码块、同步方法中出现了未处理的Error或Exception,导致异常结束
    4、当前线程在同步代码块、同步方法中执行了线程对象的wait()方法,当前线程暂停,并释放锁。

    不会释放锁的操作:

    1、线程执行同步代码块或同步方法时,程序调用Thread.sleep()、Thread.yield()方法暂停当前线程的执行。
    2、线程执行同步代码块时,其他线程调用了该线程的suspend()方法将该线程挂起,该线程不会释放锁(同步监视器)。

    应尽量避免使用suspend()和resume()来控制线程

    线程通信

    • wait():一旦执行到此方法,就使得当前线程进入阻塞状态。直到其他线程唤醒为止。

    • notify():一旦执行到此方法,就会唤醒其它被wait()的线程中优先级最高的一个。

    • notifyAll():一旦执行到此方法,就会唤醒其它所有被wait()的线程

    • 要求:
      1.如上的三个方法必须使用在同步方法或者同步代码块中。

    • 2.如上的三个方法的调用者必须是同步方法或者同步代码块的同步监视器!

    Java.lang.Object提供的这三个方法只有在synchronized方法或synchronized代码块中才能使用,否则会报如下异常:

    java.lang.IllegalMonitorStateException

    在当前线程中调用方法:对象.wait()/wait() 功能,使当前线程进入等待(某对象)状态 ,直到另一线程对该对象发出 notify (或notifyAll) 为止。
    调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁) 调用此方法后,当前线程将释放对象监控权 ,然后进入等待 在当前线程被notify后,要重新获得监控权,然后从断点处继续代码的执行。

    在当前线程中调用方法:对象名.notify() 功能,唤醒等待该对象监控权的一个线程。
    调用方法的必要条件:当前线程必须具有对该对象的监控权(加锁)

    死锁:不同的线程分别占用对方需要的同步资源不放弃,都在等待对方放弃自己需要的同步资源,就形成了线程的死锁

    展开全文
  • 本关任务:利用多线程相关知识控制三个线程,依照先后顺序顺序输出。 相关知识(略) 编程要求 请仔细阅读右侧代码,在 Begin-End 区域内进行代码补充,使线程依照先后顺序依次输出JavaThread+线程名。 提示:我们...

    第1关:顺序输出

    任务描述

    本关任务:利用多线程相关知识控制三个线程,依照先后顺序顺序输出。

    相关知识(略)

    编程要求

    请仔细阅读右侧代码,在 Begin-End 区域内进行代码补充,使线程依照先后顺序依次输出JavaThread+线程名

    提示:我们知道线程的执行结果是随机的,什么时候执行线程是看哪一个线程抢占到了CPU的资源,现在请你利用所学知识使多个线程开启之后依照先后顺序执行。

    可以参考的实训有:Java高级特性 - 多线程基础(2)常用函数

    测试说明

    测试输入:

    预期输出:

    JavaThreadAA

    JavaThreadBB

    JavaThreadCC

    JavaThreadAA

    JavaThreadBB

    JavaThreadCC

    JavaThreadAA

    JavaThreadBB

    JavaThreadCC

    JavaThreadAA

    JavaThreadBB

    JavaThreadCC

    JavaThreadAA

    JavaThreadBB

    JavaThreadCC


    开始你的任务吧,祝你成功!

    代码示例

    如果超了时间限制,加一下System.exit(0)停止就行

    package step1;
    
    public class Task {
    	public static void main(String[] args) throws Exception {
    		/********* Begin *********/
    		// 在这里创建线程, 开启线程
    
    		Object a = new Object();
    		Object b = new Object();
    		Object c = new Object();
    		// 在这里创建线程, 开启线程
    		MyThread th1 = new MyThread("AA", a, c);
    		MyThread th2 = new MyThread("BB", c, b);
    		MyThread th3 = new MyThread("CC", b, a);
    
    		th1.start();
    		Thread.sleep(10);
    		th2.start();
    		Thread.sleep(10);
    		th3.start();
    		Thread.sleep(10);
    		System.exit(0);
    
    		/********* End *********/
    	}
    }
    
    class MyThread extends Thread {
    	/********* Begin *********/
    
    	String threadName;
    	Object a = null;
    	Object b = null;
    
    	public MyThread(String threadName, Object a, Object b) {
    		super();
    		this.threadName = threadName;
    		this.a = a;
    		this.b = b;
    	}
    
    	public synchronized void run() {
    
    		int count = 5;
    		while (count > 0) {
    			synchronized (a) {
    				synchronized (b) {
    					System.out.println("Java Thread" + this.threadName);
    					count--;
    					b.notify();
    
    				}
    				try {
    					a.wait();
    				} catch (InterruptedException e) {
    					// TODO 自动生成的 catch 块
    					e.printStackTrace();
    				}
    			}
    		}
    
    	}
    	/********* End *********/
    }
    

    第2关:售票窗口

    任务描述

    本关任务:利用多线程技术,编写一个卖票的小程序,

    相关知识(略)

    编程要求

    目前有三个窗口同时出售20张票,需要你在右侧代码中的 Begin-End区域编写代码实现多个窗口售票的功能,具体要求如下:

    • 票数要使用同一个静态值;
    • 为保证不会出现卖出同一张票,使用java多线程同步锁(synchronizedlock)。

    解题思路:

    创建一个站台类Station,继承Thread,重写run方法,在run方法里面执行售票操作(即如果票没卖完就一直卖)!售票要使用同步锁:即有一个站台卖这张票时,其他站台要等这张票卖完!

    相关知识可以参考实训:Java高级特性 - 多线程基础(3)线程同步

    测试说明

    本关执行代码已经提前写好如下,不需要你重新编写运行代码:

     public static void main(String[] args) {
            //实例化站台对象,并为每一个站台取名字
             Station station1=new Station();
             Station station2=new Station();
             Station station3=new Station();
            // 让每一个站台对象各自开始工作
             station1.start();
             station2.start();
             station3.start();
    }
    

    测试输入:; 预期输出:

    卖出了第20张票

    卖出了第19张票

    卖出了第18张票

    卖出了第17张票

    卖出了第16张票

    卖出了第15张票

    卖出了第14张票

    卖出了第13张票

    卖出了第12张票

    卖出了第11张票

    卖出了第10张票

    卖出了第9张票

    卖出了第8张票

    卖出了第7张票

    卖出了第6张票

    卖出了第5张票

    卖出了第4张票

    卖出了第3张票

    卖出了第2张票

    卖出了第1张票

    票卖完了


    开始你的任务吧,祝你成功!

    代码示例

    需要注意的是监视器需要是一个共同的对象,不能是独立的,所以需要static

    Station.java

    package step2;
    
    /********* Begin *********/
    import java.util.concurrent.locks.ReentrantLock;
    
    //定义站台类,实现卖票的功能。
    public class Station extends Thread {
    	private static ReentrantLock lock = new ReentrantLock();
    	private static int ticket = 20;
    
    	@Override
    	public void run() {
    
    		while (true) {
    			try {
    				lock.lock();
    
    				if (ticket > 0) {
    					try {
    						Thread.sleep(10);
    					} catch (InterruptedException e1) {
    						// TODO 自动生成的 catch 块
    						e1.printStackTrace();
    					}
    					System.out.println("卖出了第" + ticket + "张票");
    					ticket--;
    				} else {
    					System.out.println("票卖完了");
    					System.exit(0);
    				}
    
    			} finally {
    
    				lock.unlock();
    
    			}
    
    		}
    	}
    
    }
    /********* End *********/
    
    

    Task.java

    package step2;
    
    public class Task {
    	
    	public static void main(String[] args) {
    		//实例化站台对象,
             Station station1=new Station();
             Station station2=new Station();
             Station station3=new Station();
         
            // 让每一个站台对象各自开始工作
             station1.start();
             station2.start();
             station3.start();
    	}
    	
    }
     
    
    
    展开全文
  • 第1关:并发编程的三个概念 第2关:使用synchronized关键字同步线程 第3关:使用线程锁(Lock)实现线程同步,使用sleep()函数解决了第三关线程随机导致的需要评测次问题 第3关:使用线程锁(Lock)实现线程同步
  • 本关任务:创建一个Java线程执行特定任务。 编程要求 请仔细阅读右侧代码,根据方法内的提示,在Begin - End区域内进行代码补充,具体任务如下: 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类,...
  • 一.传统的创见线程的两种方式. 1 Thread thread=new Thread();  thread.start(); 2 Thread thread=new Thread(new Runnable(){ });  thread.start();...4 多线程机制会降低程序运行效
  • 第一题 请仔细阅读右侧代码,根据方法内的提示,在Begin - End区域内进行代码补充,具体任务如下: 使用继承Thread类的方式创建一个名为 ThreadClassOne 的类,重写的run方法需要实现输出0-10之间的奇数,输出结果...
  • 本关任务:创建一个Java线程执行特定任务。 相关知识 不知道你有没有发现,截止目前,我们编写的代码都是在main()函数中依照编写代码的顺序从上到下依次运行的。 但是我们平常使用的软件基本都是可以个任务同时...
  • Java语言中提供了一个( )线程,自动回收动态分配的内存。 A、异步 B、消费者 C、守护 D、垃圾收集 当( )方法终止时,能使线程进入死亡状态 A、run B、setPrority C、yield D、sleep 用( )方法可以改变线程的...
  • javaStrengthen Java 高级特性增强。包括多线程增强、Java并发包、Java JMS技术、Java JVM技术、Java动态代理以及反射。
  • 本关任务:创建一个Java线程执行特定任务。 相关知识 不知道你有没有发现,截止目前,我们编写的代码都是在main()函数中依照编写代码的顺序从上到下依次运行的。 但是我们平常使用的软件基本都是可以个任务同时...
  • Educoder–Java高级特性(第五、六章)- 多线程练习题+Java反射【笔记+参考代码】 第一关 编程要求 请仔细阅读右侧代码,在 Begin-End 区域内进行代码补充,使线程依照先后顺序依次输出JavaThread+线程名。 提示...
  • java高级特性

    2018-04-09 20:54:02
    java高级特性总结,多线程的各种实现,jvm技术,以及动态代理和反射的理解
  • JavaSE示例 JavaSE部分示例代码,包括Java基础,Java高级特性(IO,集合,网络编程,多线程),Java8新特性(Lambda表达式,stream等)
  • Educoder–Java高级特性(第四章)- 多线程基础(3)线程同步【笔记+参考代码】 第一关 1.在并发编程中,我们需要以下哪几个特性来保持多线程程序执行正确( ABD ) A、可见性 B、原子性 C、并发性 D、有序性 2.请...
  • Educoder–Java高级特性(第四章)- 多线程基础(1)使用线程【笔记+参考代码】 第一关 编程要求 请仔细阅读右侧代码,根据方法内的提示,在Begin - End区域内进行代码补充,具体任务如下: 使用继承Thread类的...
  • Educoder–Java高级特性(第五章)- (2)常用函数【笔记+参考代码】 第一关 1.有三种原因可以导致线程不能运行,它们是( ABC ) A、等待 B、阻塞 C、休眠 D、挂起及由于I/O操作而阻塞 2.Java语言中提供了一个( ...
  • Java高级特性.bmp

    2019-08-04 21:32:38
    Java高级特性思维导图,不包括多线程,很详细,很高清,java入门必备秘籍~

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 75,559
精华内容 30,223
关键字:

java高级特性多线程

java 订阅