java 内部类来将线程 代码隐藏在类中

package org.rui.thread.basic;

import java.util.concurrent.TimeUnit;

/**
 * 有时通过使用内部类来将线程 代码隐藏在类中 将会很有用,就像下面这样:
 * -----
 * InnerThread1创建了一个扩展自thread的匿名内部类,并且在构造器中创建了这个内部类的一个实例。
 * 如果内部类具有你在其他方法中需要访问的特殊能力 (新方法)
 * 那这么做将会很有意义。但是,在大多数时候,创建线程的原因只是为了使用thread的能力,因此不必创建匿名内部类
 * 并且将其向上转型为thread引用 t。 如果类中的其他方法需要访问t 那它们可以通过thread接口来实现.
 * 并且不需要了解该对象的确切类型。
 *  该示例的第三个和第四个 类重复了前面的两个类,但是它们使用的是runnable接口  而不是Thread类
 *
 * @author lenovo
 *
 */
////////////InnerThread1///////////////////////////////
class InnerThread1{
	private int countDown=5;
	private Inner inner;

	public InnerThread1(String name){
		inner=new Inner(name);
	}
		//内部类
		private class Inner extends Thread
		{
			Inner(String name)
			{
				super(name);
			    start();
			}
			@Override
			public void run() {
				try {
					while(true)
					{
						System.out.println(this);
						if(--countDown==0)return;
						sleep(100);
					}
				} catch (InterruptedException e) {
					System.out.println("interrupted");
				}
			}

			public String toString(){return getName()+" : " +countDown; }
		}

}

	////////////InnerThread2///////////////////////////////
	class InnerThread2
	{
		private int countDown=5;
		private Thread t;

		public InnerThread2(String name){
		 t=new Thread(name)
		 {
			 @Override
			public void run() {
				try {
					while(true)
					{
						System.out.println(this);
						if(--countDown==0)return;
						sleep(10);
					}
				} catch (InterruptedException e) {
					System.out.println("interrupted");
				}
			}

			public String toString() {
				return getName()+" : "+countDown;
			}
		 };
		 t.start();
		}
	}
////////////InnerRunnable1///////////////////////////////
	class InnerRunnable1
	{
		private int countDown=5;
		private Inner inner;
		public InnerRunnable1(String name)
		{
			inner=new Inner(name);//实例内部类
		}
		//内部类实现线程
		private class Inner implements Runnable
		{
			Thread t;
			Inner(String name)
			{
				t=new Thread(this,name);
				t.start();
			}
			@Override
			public void run() {
				try {
					while(true)
					{
						System.out.println(this);
						if(--countDown==0)
						{
							return;
						}
						TimeUnit.MILLISECONDS.sleep(10);
					}
				} catch (Exception e) {
					System.out.println("interrupted");
				}
			}
			@Override
			public String toString() {
				return t.getName()+" : "+countDown;
			}
		}
	}

	////////////InnerRunnable1///////////////////////////////
	class InnerRunnable2
	{
		private int countDown=5;
		private Thread t;
		//构造器实现线程
		public InnerRunnable2(String name)
		{
			t=new Thread(new Runnable()
			{
				@Override
				public void run()
				{
					try {
						while(true)
						{
							System.out.println(this);
							if(--countDown==0)
							{
								return;
							}
							TimeUnit.MILLISECONDS.sleep(10);
						}
					} catch (Exception e) {
						System.out.println("interrupted");
					}
				}
				@Override
				public String toString()
				{
					return Thread.currentThread().getName()+" : "+countDown;
				}

			});

			t.start();
		}
	}
/////////////////////////////////a separate method to run some code as a task///////////////////////////////////////////////////
	class ThreadMethod
	{
		private int countDown=5;
		private Thread t;
		private String name;
		public ThreadMethod(String name){this.name=name;}

		public void runTask()
		{
			if(t==null)
			{
				t=new Thread(name)
				{
					@Override
					public void run() {
						try {
							while(true)
							{
								System.out.println(this);
								if(--countDown==0)return;
								sleep(10);
							}
						} catch (Exception e) {
							System.out.println("interrupted");
						}
					}
					@Override
					public String toString()
					{
						return getName()+" : "+countDown;
					}
				};
				t.start();
			}
		}
	}

	/////////////////////////////////main///////////////////////////////////////////////////
public class ThreadVariations {

	public static void main(String[] args)
	{
	    new InnerThread1("InnerTherad1");
	    new InnerThread2("InnerThread2");
	    new InnerRunnable1("InnerRunnable1");
	    new InnerRunnable2("InnerRunnable2");
	    new ThreadMethod("ThreadMethod").runTask();;
	}

}

java 内部类来将线程 代码隐藏在类中

时间: 2024-07-30 00:56:02

java 内部类来将线程 代码隐藏在类中的相关文章

Java线程状态及Thread类中的主要方法

要想实现多线程,就必须在主线程中创建新的线程对象. 任何线程一般具有5种状态,即创建,就绪,运行,阻塞,终止. 创建状态: 在程序中用构造方法创建了一个线程对象后,新的线程对象便处于新建状态,此时,他已经有了相应的内存空间和其他资源,但还处于不可运行状态. 就绪状态: 新建线程对象后,调用该线程的start()方法可以启动线程.当线程启动时,线程进入就绪状态.此时,线程将进入线程队列排队,等待CPU服务,这表明它已经具备了运行条件.-------(运行start()方法只是进入就绪状态,并没有开

java中静态代码块(static{...}),局部代码块(方法中{...}),构造代码块(类中{...})区别。

1.局部代码块: 格式:在方法中{局部代码块执行语句} 局部代码块,又叫普通代码块.它是作用在方法中的代码块. 作用:是控制变量的生命周期. 在程序中当我们定义完成一个局部变量x之后,并且在接下来的代码中,不想再用到它时,那么就没必要让x在内存中继续占用空间.因此就有了局部代码块. 2.构造代码块: 格式:在类中{构造代码块执行语句} 作用:就是给所有对象进行初始化. 注意几点: 1)每次创建对象他都会执行. 2)构造代码快是优于构造函数执行. 3)构造代码块与构造函数的区别是:构造代码块是给所

wait(),notify(),notifyAll()用来操作线程为什么定义在Object类中?

这些方法存在于同步中: 使用这些方法必须标识同步所属的锁: 锁可以是任意对象,所以任意对象调用方法一定定义在Object类中. Condition是在java 1.5中才出现的,它用来替代传统的Object的wait().notify()实现线程间的协作,相比使用Object的wait().notify(),使用Condition1的await().signal()这种方式实现线程间协作更加安全和高效.因此通常来说比较推荐使用Condition,在阻塞队列那一篇博文中就讲述到了,阻塞队列实际上是

五种内部类形式将线程隐藏于类中

1.使用普通内部类继承Thread类 public class ThreadTestOne { private int countDown = 5; private Inner inner; private class Inner extends Thread{ Inner(String name){ super(name); start(); } public void run(){ while(true){ System.out.println(this); if(--countDown =

Java的的简单线程复制文件工具类FileUtil2.0

相对于版本1.0,多了很多方法, 比如,获取文件的后缀名,或修改后缀名和一些文件的简单操作. 文件复制到文件,文件复制到路径,路径下文件复制到新路径下, 代码如下,请享用: 1 package cn.util; 2 3 import java.io.*; 4 5 /** 6 * 线程的方式实现文件的复制. 7 文件的复制需要四个参数:1,路径或文件),2路径或文件,3,是否覆盖,4,是否追加, 8 多文件复制还需要加时间参数(毫秒). 9 * 以及File类实例的简单创建, 10 * 11 *

线程中断:Thread类中interrupt()、interrupted()和 isInterrupted()方法详解

首先看看官方说明: interrupt()方法 其作用是中断此线程(此线程不一定是当前线程,而是指调用该方法的Thread实例所代表的线程),但实际上只是给线程设置一个中断标志,线程仍会继续运行. interrupted()方法 作用是测试当前线程是否被中断(检查中断标志),返回一个boolean并清除中断状态,第二次再调用时中断状态已经被清除,将返回一个false. isInterrupted()方法 作用是只测试此线程是否被中断 ,不清除中断状态  下面我们进行测试说明: 定义一个MyThr

java 27 - 6 反射之 通过配置文件运行类中的方法

在以前,如果我们想要调用一个类中的方法,只能这样子: 例: 有Cat和Dog两个类,里面有eat和run两个成员方法: 1 public class Dog { 2 3 public void eat() { 4 System.out.println("狗吃肉"); 5 } 6 7 public void run() { 8 System.out.println("狗刨"); 9 } 10 } public class Cat { public void eat()

【解惑】领略Java内部类的“内部”

转自:http://android.blog.51cto.com/268543/384809 内部类有两种情况: (1) 在类中定义一个类(私有内部类,静态内部类) (2) 在方法中定义一个类(局部内部类,匿名内部类) 1.私有内部类 -- 在方法之间定义的内部类,非静态 我们首先看看类中内部类的两个特点: (1) 在外部类的作用范围内可以任意创建内部类对象,即使内部类是私有的(私有内部类).即内部类对包围它的外部类可见. 例如 (实际上,内部类是可以设置为public公开的,但一般我是当做成员

Java内部类是如何实现的

内部类(inner class)是定义在另一个类中的类. 内部类方法可以访问该类定义所在的作用域中的数据,包括私有的数据. 内部类可以对同一个包中的其他类隐藏起来 当想定义一个回调函数且不想编写大量代码时,使用匿名(anonymous)内部类比较便捷. 以下简单举例: 一个时钟需要两个参数:发布通告的时间间隔以及开关铃声的标志. public class TalkingClock { private int interval; private boolean beep; public Talki