android thread实例

最新推荐文章于 2023-11-17 18:31:19 发布
最新推荐文章于 2023-11-17 18:31:19 发布
阅读量5.6w 收藏 40
点赞数 1
分类专栏： android 文章标签： thread android class button application object

本文转载自http://blog.csdn.net/z496844387/article/details/6412507


创建线程的方法：

官网的说法：

There are basically two main ways of having a Thread execute application code. 
One is providing a new class that extends Thread and overriding its run() method. 
The other is providing a new Thread instance with a Runnable object during its creation. In both cases, the start() method must be called to actually execute the new Thread.

扩展Thread的示例代码：

public class CommonTestActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        new Thread(){
        	public void run(){
        		System.out.println("Thread is running.");
        	}
        }.start();
    }
}

使用Runnable的示例代码：

public class CommonTestActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        new Thread(r).start();
    }
    
    Runnable r = new Runnable() {
        @Override
        public void run() {        	
            System.out.println("Runnable running ");
        }
    };
    
}

经典实例：

多个窗口一起卖火车票问题。假设有3个窗口同时售票，共有10张火车票代售。启动三个线程卖共同的10张票。

1. 使用下面的代码试图实现功能

public class CommonTestActivity extends Activity{
	
	private Button mybutton;
	private TextView mytext;

	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);
		mybutton = (Button) findViewById(R.id.button);
		mytext = (TextView) findViewById(R.id.text);
		
        mybutton.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				// TODO Auto-generated method stub
		        MyThread myThread1 = new MyThread(); 
		        MyThread myThread2= new MyThread(); 
		        MyThread myThread3 = new MyThread(); 
		        myThread1.start(); 
		        myThread2.start(); 
		        myThread3.start(); 
			}
        });
       
	}

	class MyThread extends Thread {
		private int tickets = 10;

		public void run() {
			for (int i = 0; i < 200; i++) {
				if (tickets > 0) {
					System.out.println(Thread.currentThread().getName() + "==>"
							+ tickets--);
				}
			}
		}
	}

}
输出如下 

11-17 22:45:01.234: I/System.out(672): Thread-10==>10
11-17 22:45:01.234: I/System.out(672): Thread-10==>9
11-17 22:45:01.234: I/System.out(672): Thread-10==>8
11-17 22:45:01.234: I/System.out(672): Thread-10==>7
11-17 22:45:01.234: I/System.out(672): Thread-10==>6
11-17 22:45:01.234: I/System.out(672): Thread-10==>5
11-17 22:45:01.234: I/System.out(672): Thread-10==>4
11-17 22:45:01.234: I/System.out(672): Thread-10==>3
11-17 22:45:01.244: I/System.out(672): Thread-10==>2
11-17 22:45:01.244: I/System.out(672): Thread-10==>1
11-17 22:45:01.244: I/System.out(672): Thread-11==>10
11-17 22:45:01.244: I/System.out(672): Thread-11==>9
11-17 22:45:01.244: I/System.out(672): Thread-11==>8
11-17 22:45:01.244: I/System.out(672): Thread-11==>7
11-17 22:45:01.244: I/System.out(672): Thread-11==>6
11-17 22:45:01.254: I/System.out(672): Thread-11==>5
11-17 22:45:01.254: I/System.out(672): Thread-11==>4
11-17 22:45:01.254: I/System.out(672): Thread-11==>3
11-17 22:45:01.254: I/System.out(672): Thread-11==>2
11-17 22:45:01.254: I/System.out(672): Thread-11==>1
11-17 22:45:01.264: I/System.out(672): Thread-12==>10
11-17 22:45:01.264: I/System.out(672): Thread-12==>9
11-17 22:45:01.264: I/System.out(672): Thread-12==>8
11-17 22:45:01.264: I/System.out(672): Thread-12==>7
11-17 22:45:01.264: I/System.out(672): Thread-12==>6
11-17 22:45:01.274: I/System.out(672): Thread-12==>5
11-17 22:45:01.274: I/System.out(672): Thread-12==>4
11-17 22:45:01.274: I/System.out(672): Thread-12==>3
11-17 22:45:01.274: I/System.out(672): Thread-12==>2
11-17 22:45:01.274: I/System.out(672): Thread-12==>1

分析：

运行结果与预期不一致，分析可以看出3个线程各种卖各自的10张票，而不是共同的10张票。

在上面的代码中，只能保证：每个线程都将启动，每个线程都将运行直到完成。一系列线程以某种顺序启动并不意味着将按该顺序执行。对于任何一组启动的线程来说，调度程序不能保证其执行次序，持续时间也无法保证。


2. 只修改onClick里面的代码，并分析运行结果

public void onClick(View v) { 
    //实例化线程对象 
    MyThread myThread = new MyThread(); 
    new Thread(myThread, "窗口1").start(); 
    new Thread(myThread, "窗口2").start(); 
    new Thread(myThread, "窗口3").start(); 
}

输出如下

11-17 22:49:17.314: I/System.out(708): 窗口1==>10
11-17 22:49:17.314: I/System.out(708): 窗口1==>9
11-17 22:49:17.314: I/System.out(708): 窗口1==>8
11-17 22:49:17.314: I/System.out(708): 窗口1==>7
11-17 22:49:17.314: I/System.out(708): 窗口1==>6
11-17 22:49:17.324: I/System.out(708): 窗口1==>5
11-17 22:49:17.324: I/System.out(708): 窗口1==>4
11-17 22:49:17.324: I/System.out(708): 窗口1==>3
11-17 22:49:17.324: I/System.out(708): 窗口1==>2
11-17 22:49:17.324: I/System.out(708): 窗口1==>1

分析：

我认为此处3个窗口已经是在卖共同的10张票了，只不过由于没有进行线程同步才造成数据混乱。

线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。

3. 下面继续修改代码，验证我刚得猜测。

public void onClick(View v) { 
    //实例化线程对象 
    MyThread myThread = new MyThread(); 
    new Thread(myThread, "窗口1").start(); 
    new Thread(myThread, "窗口2").start(); 
    new Thread(myThread, "窗口3").start(); 
}

class MyThread extends Thread{ 
    private int tickets = 10; 
    public void run() { 
        for(int i = 0; i< 200; i++){ 
                sell(); 
        } 
    } 
    public synchronized  void sell(){ 
            if(tickets > 0) 
            { 
                System.out.println(Thread.currentThread().getName() + "==>" + tickets--); 
            } 
    } 
}

运行结果：

05-11 08:53:31.986: INFO/System.out(7116): 窗口1==>10 
05-11 08:53:32.006: INFO/System.out(7116): 窗口1==>9 
05-11 08:53:32.016: INFO/System.out(7116): 窗口1==>8 
05-11 08:53:32.066: INFO/System.out(7116): 窗口1==>7 
05-11 08:53:32.086: INFO/System.out(7116): 窗口1==>6 
05-11 08:53:32.106: INFO/System.out(7116): 窗口1==>5 
05-11 08:53:32.106: INFO/System.out(7116): 窗口1==>4 
05-11 08:53:32.126: INFO/System.out(7116): 窗口1==>3 
05-11 08:53:32.146: INFO/System.out(7116): 窗口1==>2 
05-11 08:53:32.146: INFO/System.out(7116): 窗口1==>1

分析：

一个对象只有一个锁。所以，如果一个线程获得该锁，就没有其他线程可以获得锁，直到第一个线程释放（或返回）锁。这也意味着任何其他线程都不能进入该对象上的synchronized方法或代码块，直到该锁被释放。

释放锁是指持锁线程退出了synchronized同步方法或代码块。

上述代码没有Thread.sleep(10)，换句话说线程一一直处于运行状态，没有释放锁，没有给其他线程运行的机会。

4. 根据上述分析，修改代码如下：

public void onClick(View v) { 
        //实例化线程对象 
        MyThread myThread = new MyThread(); 
        new Thread(myThread, "窗口1").start(); 
        new Thread(myThread, "窗口2").start(); 
        new Thread(myThread, "窗口3").start(); 
    } 
    class MyThread extends Thread{ 
        private int tickets = 10; 
        public void run() { 
            for(int i = 0; i< 200; i++){ 
                try{ 
                    sell(); 
                    Thread.sleep(10); 
                }catch (InterruptedException e) { 
                    System.out.println("我被打断了" + Thread.currentThread().getName()); 
                    e.printStackTrace(); 
                }

            } 
        } 
        public synchronized  void sell(){ 
                if(tickets > 0) 
                { 
                    System.out.println(Thread.currentThread().getName() + "==>" + tickets--); 
                } 
        } 
    }

运行结果：

05-11 09:17:07.496: INFO/System.out(7898): 窗口1==>10 
05-11 09:17:07.528: INFO/System.out(7898): 窗口1==>9 
05-11 09:17:07.546: INFO/System.out(7898): 窗口1==>8 
05-11 09:17:07.577: INFO/System.out(7898): 窗口1==>7 
05-11 09:17:07.626: INFO/System.out(7898): 窗口3==>6 
05-11 09:17:07.626: INFO/System.out(7898): 窗口2==>5 
05-11 09:17:07.636: INFO/System.out(7898): 窗口1==>4 
05-11 09:17:07.646: INFO/System.out(7898): 窗口2==>3 
05-11 09:17:07.646: INFO/System.out(7898): 窗口1==>2 
05-11 09:17:07.656: INFO/System.out(7898): 窗口3==>1

分析：

此次得出的正是我们想要的结果！O(∩_∩)O~


awebkit
关注
  • 1
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
简单实例化解析安卓Thread线程
leerfun的博客
11-09 1568
进程(Process)与线程(Thread)进程是某个正在执行的应用程序的执行过程，该过程包括应用程序在执行之前向操作系统(OS)申请系统资源、开始执行、整个执行过程、执行结束。从用户体验的角度上来说，若干个进程是处于“同时执行”的状态的，事实上并不是这样！操作系统会实现CPU的调度，使得CPU在多个进程之间高频率的切换，由于切换速度快，所以，从正常的视觉和听觉等感观是无法察觉的，即体验到的就是“同
android线程实现方法,Android 线程 thread 两种实现方法！
weixin_36160690的博客
05-25 2236
这篇文章中有三点需要提前说明一下，一：在Android中有两种实现线程thread的方法：一种是，扩展Java.lang.Thread类另一种是，实现Runnable接口二：Thread类代表线程类，它的两个最主要的方法是：run()——包含线程运行时所执行的代码Start()——用于启动线程三：Handler 机制，它是Runnable和Activity交互的桥梁，在run方法中发送Messag...
Android 线程thread的两种实现方法(必看)
01-20
这篇文章中有三点需要提前说明一下， 一：在android中有两种实现线程thread的方法： 一种是，扩展java.lang.Thread类 另一种是，实现Runnable接口 二：Thread类代表线程类，它的两个最主要的方法是： run()——包含线程运行时所执行的代码 Start()——用于启动线程 三： Handler 机制，它是Runnable和Activity交互的桥梁，在run方法中发送Message，在Handler里，通过不同的Message执行不同的任务。 下面分别给出两种线程的实现方法，其一，扩展java.lang.Thread类，也就是把run()方法写到线程里面：
Android中线程Thread的使用
子云心的博客
03-06 5608
定义 主线程是指进程拥有的线程，或叫UI线程，Java中默认情况下一个进程只有一个线程，这个线程就是主线程。主线程不能执行耗时的任务,所以在一些耗时处理时，就得使用子线程。Android沿用了Java的线程模型，从Android3.0开始系统要求网络访问也必须在子线程中进行，否则网络访问将会失败并抛出NetworkOnMainThreadException异常。在Android里如果主线程被执行...
Android Thread 浅析和使用小结
再简单的事，也要用心做成！
12-22 9562
一.线程的状态 线程包括几个状态： 创建（new) Thread thread=new Thread; 就绪（runnable） thread.start(); 运行（running） 线程只能从就绪状态进入到运行状态 阻塞（blocked） 该状态是线程因为某种原因放弃了cpu使用权限，暂时停止运行。 阻塞的情况有三种...
Android 多线程：Thread理解和使用总结
yangjunjin的博客
03-22 857
Android 多线程：Thread理解和使用总结Marker_Sky关注0.8182017.10.19 20:43:14字数 1,372阅读 13,258 Android Thread目录.png 一、Android中的Thread 定义：线程，可以看作是进程的一个实体，是CPU调度和分派的基本单位，它是比进程更小的能独立运行的基本单位。 1.1 Thread主要函数 函数名...
Android Thread 介绍与实例
09-05
Android Thread 介绍与实例，需要的朋友可以参考一下
android thread类pc验证实例
09-24
该实例是拿出android thread类，在PC上验证的实例，可以根据自己的验证需求，验证！
android 实例精解
07-29
这是我从网上搜集来的一些android 经典实例，包含了：使用Thread以及进度对话框示例、利用ListView实现自己的电话联系人、触摸反馈等几个经典实例的精讲和完整的项目文件……希望能大家有帮助
Android实例HandlerThread源码分析
01-04
我们知道Thread线程是一次性消费品，当Thread线程执行完一个耗时的任务之后，线程就会被自动销毁了。如果此时我又有一 个耗时任务需要执行，我们不得不重新创建线程去执行该耗时任务。然而，这样就存在一个性能问题...
Android线程管理之Thread使用总结
weixin_47250220的博客
07-30 1013
Android线程管理之Thread使用总结实现Thread两种方式示例：2.）实现Runnable接口示例：Thread主要函数Thread线程主要状态如何停止一个线程Thread线程同步问题2.）线程同步的几种方式 实现Thread两种方式 1.）继承Thread类 /** * 继承Thread方式 */ private class SyncThread extends Thread { SyncThread(String name) { super(name); } @Override public
Android Thread线程的简单使用
u012841414的博客
11-09 1037
计时功能看似成功了，但是却埋下了一个隐患，即当你销毁计时界面（可以理解为出栈）时，启动的子线程不会因此而销毁，由于其还持有显示时间的控件tv_time，导致GC不会回收，一直持有该引用，轻则卡顿，重则占满内存导致OOM，直接奔溃。用来实现同步，可以保证被修饰的函数在被其它函数调用时，如果其处于被调用中，那么其它所有要调用到该函数的线程都会被阻塞，直到其从调用的线程中返回，防止资源冲突（虽然在上诉的代码中没有很好体现，但是还是粗略讲解下作用）至此，线程的简单使用到此结束，有不对的地方请各位小伙伴不吝指出。
Android中的Thread详解
最新发布
Androiddddd的博客
11-17 261
线程（英语：thread）在计算机科学中，是将进程划分为两个或多个线程（实例）或子进程，由单处理器（单线程）或多处理器（多线程）或多核处理系统并发执行。—— 维基百科无论在Android还是java开发甚至其他语言开发，大多数都逃不过多线程的话题，当然dart等语言除外（不过也有isolate的概念）。线程是操作系统CPU资源分配调度的一个单元，在Java中，最常见的就是Thread类，通过该类可以让我们在多线程创建、启动、执行等操作更加得心应手。
Android - 线程 Thread
HugMua的博客
06-02 911
一个线程总是由另一个线程启动，所以总有一条特殊的线程即主线程。
android thread知识你还记得多少?
高级开发者进阶ing... QaQ
01-17 2682
android 线程知识你还记得多少?常见创建线程的几种方式 常见创建线程的几种方式 方式一:
【Android】之【Thread】
Crazy程序猿
03-22 306
Android线程知识点整理
Android Thread之threadLoop方法
ch853199769的博客
04-12 1万+
Android Framework中的线程Thread及它的threadLoop方法 在Framework中的Thread普遍的特点就是有一个 threadLoop方法。它到底是怎么循环起来的。 Android中java世界的Thread 先来看看java是怎么创建一个线程的。这个是最舒服的，也是我最熟悉的。 new Thread(new Runnable() { ...
Android多线程分析之二：Thread的实现
热门推荐
罗朝辉（飘飘白云）
07-10 2万+
在前文《Android多线程分析之一：使用Thread异步下载图像》中演示了如何使用 Thread 处理异步事务。示例中这个 Java Thread 类都是位于 Framework 层的类，它自身是通过 JNI 转调 dalvik 里面的 Thread 相关方法实现的。因此要分析 Androd 中的线程，就需要分析这两层中的与线程相关的代码，这就是本文要探讨的主题。本文将把 Framework 层中的 Java Thread 称为 Android 线程/Thread，而把 dalvik 中的 Thread
Android 线程 thread 两种实现方法！
weixin_33690367的博客
06-08 86
2019独角兽企业重金招聘Python工程师标准>>> ...
android handler实例
05-26
以下是一个使用 Handler 的 Android 示例： ``` public class MainActivity extends AppCompatActivity { private TextView textView; private Handler handler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); textView = findViewById(R.id.textView); // 初始化 Handler handler = new Handler(); // 启动一个新线程 new Thread(new Runnable() { @Override public void run() { // 模拟耗时操作 try { Thread.sleep(5000); } catch (InterruptedException e) { e.printStackTrace(); } // 通过 Handler 更新 UI handler.post(new Runnable() { @Override public void run() { textView.setText("Hello Handler!"); } }); } }).start(); } } ``` 在这个示例中，我们在主线程中创建了一个 Handler 的实例。然后，我们启动了一个新线程来模拟一个耗时操作，这个操作将会在 5 秒钟后通过 Handler 来更新 UI。当线程睡眠 5 秒钟后，我们通过 `handler.post()` 方法来将一个 Runnable 对象发布到主线程的消息队列中，这个 Runnable 对象将会在主线程中执行。在这里，我们将 `textView` 的文本设置为 "Hello Handler!"。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值