`

Java之线程(匿名内部类)

    博客分类:
  • Java
阅读更多
1 Thread对象
Thread t = new Thread(
				new Thread(){
					@Override
					public void run() {
					
						while(true){
							try {
								Thread.sleep(1000);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							System.out.println("1: "+Thread.currentThread().getName());
							System.out.println("2: "+this.getName());
						}						
						
					}
				}
		);
		t.start();		

2 Runnable接口
Thread t2 = new Thread(
				new Runnable(){
					@Override
					public void run() {
						
						while(true){
							try {
								Thread.sleep(1000);
							} catch (InterruptedException e) {
								e.printStackTrace();
							}
							System.out.println("3: "+Thread.currentThread().getName());							
						}						
					}
				}
		);
		t2.start();

下面会执行哪部分代码呢!
//只要重写了run方法,你从构造函数传递进去的线程对象就不会在执行		
		new Thread(new Runnable(){
			
			@Override
			public void run() {
				
				while(true){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("runnable: "+Thread.currentThread().getName());							
				}						
			}
		}
		){
			
			@Override
			public void run() {
				
				while(true){
					try {
						Thread.sleep(1000);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("thread: "+Thread.currentThread().getName());							
				}
				
			}
		}.start();

输出结果如下:
3: Thread-2
1: Thread-1
2: Thread-0
thread: Thread-3

以下代码来自于:JAVA编程思想第四版,说明加了是否加线程的区别!
Counter1 .java没有加线程的表现!
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

public class Counter1 extends Applet {	
	
	private static final long serialVersionUID = 1L;
	private int count = 0;
	private Button onOff = new Button("Toggle"), start = new Button("Start");
	private TextField t = new TextField(10);
	private boolean runFlag = true;

	public void init() {
		add(t);
		start.addActionListener(new StartL());
		add(start);
		onOff.addActionListener(new OnOffL());
		add(onOff);
	}

	@SuppressWarnings("static-access")
	public void go() {
		while (true) {
			try {
				Thread.currentThread().sleep(100);
			} catch (InterruptedException e) {
			}
			if (runFlag)
				t.setText(Integer.toString(count++));

		}
	}

	class StartL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			go();
		}
	}

	class OnOffL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			runFlag = !runFlag;
		}
	}

	public static void main(String[] args) {
		Counter1 applet = new Counter1();
		Frame aFrame = new Frame("Counter1");
		aFrame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		aFrame.add(applet, BorderLayout.CENTER);
		aFrame.setSize(300, 200);
		applet.init();
		applet.start();
		aFrame.setVisible(true);
	}
}

Counter2i.java加了线程结果大不一样了,加了个内部类,它继承了Thread
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

public class Counter2i extends Applet {
	
	private static final long serialVersionUID = 1L;

	private class SeparateSubTask extends Thread {
		int count = 0;
		boolean runFlag = true;

		SeparateSubTask() {
			start();
		}

		public void run() {
			while (true) {
				try {
					sleep(100);
				} catch (InterruptedException e) {
				}
				if (runFlag)
					t.setText(Integer.toString(count++));
			}
		}
	}

	private SeparateSubTask sp = null;
	private TextField t = new TextField(10);
	private Button onOff = new Button("Toggle"), start = new Button("Start");

	public void init() {

		add(t);
		start.addActionListener(new StartL());
		add(start);
		onOff.addActionListener(new OnOffL());
		add(onOff);
	}

	class StartL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if (sp == null)
				sp = new SeparateSubTask();
		}
	}

	class OnOffL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if (sp != null)
				sp.runFlag = !sp.runFlag; // invertFlag();
		}
	}

	public static void main(String[] args) {
		Counter2i applet = new Counter2i();
		Frame aFrame = new Frame("Counter2i");
		aFrame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		aFrame.add(applet, BorderLayout.CENTER);
		aFrame.setSize(300, 200);
		applet.init();
		applet.start();
		aFrame.setVisible(true);
	}
}

Counter3.java它实现了Runnable接口
import java.awt.*;
import java.awt.event.*;
import java.applet.*;

public class Counter3 extends Applet implements Runnable {
	
	private static final long serialVersionUID = 1L;
	private int count = 0;
	private boolean runFlag = true;
	private Thread selfThread = null;
	private Button onOff = new Button("Toggle"), start = new Button("Start");
	private TextField t = new TextField(10);

	public void init() {
		add(t);
		start.addActionListener(new StartL());
		add(start);
		onOff.addActionListener(new OnOffL());
		add(onOff);
	}

	@SuppressWarnings("static-access")
	public void run() {
		while (true) {
			try {
				selfThread.sleep(100);
			} catch (InterruptedException e) {
			}
			if (runFlag)
				t.setText(Integer.toString(count++));
		}
	}

	class StartL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			if (selfThread == null) {
				selfThread = new Thread(Counter3.this);
				selfThread.start();
			}
		}
	}

	class OnOffL implements ActionListener {
		public void actionPerformed(ActionEvent e) {
			runFlag = !runFlag;
		}
	}

	public static void main(String[] args) {
		Counter3 applet = new Counter3();
		Frame aFrame = new Frame("Counter3");
		aFrame.addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
		aFrame.add(applet, BorderLayout.CENTER);
		aFrame.setSize(300, 200);
		applet.init();
		applet.start();
		aFrame.setVisible(true);
	}
}
分享到:
评论

相关推荐

    java中的匿名内部类总结

    Java 中的匿名内部类总结 Java 中的匿名内部类是一种特殊的内部类,它没有名字,因此也称为匿名类。匿名内部类是一种简洁的编程方式,能够简化代码编写,但它也有一些限制和特点。 匿名内部类的定义 匿名内部类是...

    Java 匿名内部类

    匿名内部类广泛应用于Java集合框架中的比较器(Comparator)、线程(Thread)的创建、事件监听(如ActionListener)等场景。 通过以上讲解,我们可以看出Java匿名内部类在编写简洁、高效的代码方面发挥了重要作用...

    Java4Android 35_内部类和匿名内部类

    在Java编程语言中,内部类和匿名内部类是两种特殊类型的类,它们为代码的组织和功能实现提供了独特的灵活性。本教程"Java4Android 35_内部类和匿名内部类"深入探讨了这两个概念,旨在帮助开发者更好地理解和运用它们...

    java 内部类使用(内部匿名类)

    内部类分为几种类型,包括成员内部类、局部内部类、匿名内部类以及方法参数内部类。 1. **成员内部类**:成员内部类就像是外部类的一个普通成员,可以是静态或非静态的。非静态内部类拥有对外部类的引用,可以直接...

    java线程内部类练习.rar

    此外,静态内部类(也称为嵌套类)可以作为线程的实现,它具有比匿名内部类更高的复用性,因为它们可以像普通类一样被实例化,而不依赖于外部类的实例。静态内部类可以访问外部类的静态成员,但不能直接访问非静态...

    JAVA_匿名内部类

    Java匿名内部类是Java语言中一个独特且强大的特性,它允许我们在不定义完整类的情况下创建对象。这种类没有名字,通常用作一次性实现某个接口或继承某个类的情况,尤其是在需要简洁代码的地方。以下是对Java匿名内部...

    发两个匿名内部类使用的例子

    在Java编程语言中,匿名内部类是一种特殊的类,它没有名字,通常用于简化代码和实现特定功能。在标题“发两个匿名内部类使用的例子”中,我们将会探讨两种不同的场景,如何利用匿名内部类来解决问题。这篇博客文章的...

    java8 探讨与分析匿名内部类、lambda表达式、方法引用的底层实现的测试用例

    例如,`Runnable`接口常用于线程,我们可以通过匿名内部类快速创建一个线程并实现run()方法。 2. **Lambda表达式**: Lambda表达式是Java 8的核心特性之一,它提供了一种简洁的表示函数式接口实现的方式。传统的...

    匿名内部类实现接口回调

    匿名内部类是Java中的一种特殊类,它没有名称,可以直接实例化,并且可以继承一个类或实现一个(多个)接口。在接口回调的场景下,我们可以使用匿名内部类快速地创建一个实现了接口的实例,而无需定义一个新的类。...

    内部类 匿名内部类 内部接口 对比说明

    总结一下,内部类、匿名内部类和内部接口在Java编程中提供了一种强大的工具,它们可以帮助我们更好地组织代码,实现封装和模块化。在Android开发中,它们常用于事件监听、线程管理、回调函数等场景,增强了代码的...

    java中匿名内部类详解

    Java中的匿名内部类是一种特殊的类,它没有名称且通常用于一次性使用的情况,目的是简化代码编写。下面我们将深入探讨匿名内部类的各个方面。 1. **匿名内部类定义**: 匿名内部类,正如其名,是没有名字的类。它...

    java中的匿名内部类详细总结

    在Java多线程编程中,匿名内部类被广泛使用。你可以通过继承 `Thread` 类或者实现 `Runnable` 接口来创建新的线程。例如,`Thread t = new Thread() {...}` 和 `Runnable r = new Runnable() {...}` 分别展示了两种...

    Handler对象中使用匿名内部类或非静态内部类正确地释放消息避免内存泄漏或增加Native内存

    然而,不当使用Handler,尤其是结合匿名内部类或非静态内部类,可能导致内存泄漏和Native内存增加,这对应用性能和稳定性造成负面影响。 首先,我们要理解内存泄漏的概念。内存泄漏是指程序中已分配的内存没有被...

    匿名内部类_Anoymous_Inner_

    匿名内部类是Java编程语言中一个独特而强大的特性,它允许开发者在不定义单独类的情况下实现接口或继承抽象类。这种类没有名称,通常用于快速实现特定功能或回调机制,尤其是在处理事件监听器时非常常见。匿名内部类...

    使用内部类实现线程

    这种方式下,我们无需单独定义一个内部类,而是直接在创建线程的地方定义一个匿名内部类实现 `Runnable`。 总之,内部类是Java中实现线程的一种灵活且强大方式,它允许我们轻松地创建线程并与其他代码进行紧密交互...

    java代码笔记2010-06-01:Java内部类 静态内部类 局部内部类 明明内部类;StringBuffer reverse的使用;

    内部类可以分为四种类型:静态内部类、成员内部类(非静态内部类)、局部内部类和匿名内部类。 1. **静态内部类**: 静态内部类与普通的成员内部类不同,它不持有对外部类的引用。因此,可以像其他静态成员一样,...

    MapReduce,泛型,匿名内部类,Runnable和Callable

    总结来说,MapReduce是大数据处理的关键技术,泛型提供了强大的类型安全和代码复用,匿名内部类简化了多线程编程,而`Runnable`和`Callable`则是Java多线程编程的基础。了解和掌握这些概念对于理解现代分布式系统和...

    非常精简的匿名内部类详解.docx

    在Java编程语言中,匿名内部类是一种特殊的类,它没有名称,通常用于简洁地实现某个接口或继承某个类,尤其在只需要单个实例且无需多次复用的情况下。这种设计模式可以大大简化代码,提高可读性。下面我们将深入探讨...

Global site tag (gtag.js) - Google Analytics