androidrunnable使用_android中Runnable的用法？

最新推荐文章于 2021-06-09 09:54:43 发布
最新推荐文章于 2021-06-09 09:54:43 发布
阅读量481 收藏
点赞数
文章标签： androidrunnable使用
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39904522/article/details/111841577
版权

展开全部

只要java好就没有问题，这是3D魔方android的源码。

package com.example.android.image3D;

import android.view.SurfaceView;

import android.view.SurfaceHolder;

import android.content.Context;

import android.util.AttributeSet;

import java.util.ArrayList;

import java.util.concurrent.Semaphore;

import javax.microedition.khronos.egl.EGL10;

import javax.microedition.khronos.egl.EGL11;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.egl.EGLContext;

import javax.microedition.khronos.egl.EGLDisplay;

import javax.microedition.khronos.egl.EGLSurface;

import javax.microedition.khronos.opengles.GL;

import javax.microedition.khronos.opengles.GL10;

public class View3D extends SurfaceView implements SurfaceHolder.Callback {

private static final Semaphore sEglSemaphore = new Semaphore(1);

private boolean mSizeChanged = true;

private SurfaceHolder mHolder;

private GLThread mGLThread;

private GLWrapper mGLWrapper;

public View3D(Context context) {

super(context);

init();

}

public View3D(Context context, AttributeSet attrs) {

super(context, attrs);

init();

}

private void init() {

mHolder = getHolder();

mHolder.addCallback(this);

mHolder.setType(SurfaceHolder.SURFACE_TYPE_GPU);

}

public SurfaceHolder getSurfaceHolder() {

return mHolder;

}

public void setGLWrapper(GLWrapper glWrapper) {

mGLWrapper = glWrapper;

}

public void setRenderer(Renderer renderer) {

mGLThread = new GLThread(renderer);

mGLThread.start();

}

public void surfaceCreated(SurfaceHolder holder) {

mGLThread.surfaceCreated();

}

public void surfaceDestroyed(SurfaceHolder holder) {

mGLThread.surfaceDestroyed();

}

public void surfaceChanged(SurfaceHolder holder,

int format, int w, int h) {

mGLThread.onWindowResize(w, h);

}

public void onPause() {

mGLThread.onPause();

}

public void onResume() {

mGLThread.onResume();

}

@Override

public void onWindowFocusChanged(boolean hasFocus) {

super.onWindowFocusChanged(hasFocus);

mGLThread.onWindowFocusChanged(hasFocus);

}

public void queueEvent(Runnable r) {

mGLThread.queueEvent(r);

}

@Override

protected void onDetachedFromWindow() {

super.onDetachedFromWindow();

mGLThread.requestExitAndWait();

}

public interface GLWrapper {

GL wrap(GL gl);

}

public interface Renderer {

int[] getConfigSpec();

void surfaceCreated(GL10 gl);

void sizeChanged(GL10 gl, int width, int height);

void drawFrame(GL10 gl);

}

private class EglHelper {

EGL10 mEgl;

EGLDisplay mEglDisplay;

EGLSurface mEglSurface;

EGLConfig mEglConfig;

EGLContext mEglContext;

public EglHelper() {

}

public void start(int[] configSpec){

mEgl = (EGL10) EGLContext.getEGL();

mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

int[] version = new int[2];

mEgl.eglInitialize(mEglDisplay, version);

EGLConfig[] configs = new EGLConfig[1];

int[] num_config = new int[1];

mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1,

num_config);

mEglConfig = configs[0];

mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig,

EGL10.EGL_NO_CONTEXT, null);

mEglSurface = null;

}

public GL createSurface(SurfaceHolder holder) {

if (mEglSurface !32313133353236313431303231363533e58685e5aeb931333262383661= null) {

mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,

EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);

mEgl.eglDestroySurface(mEglDisplay, mEglSurface);

}

mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay,

mEglConfig, holder, null);

mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface,

mEglContext);

GL gl = mEglContext.getGL();

if (mGLWrapper != null) {

gl = mGLWrapper.wrap(gl);

}

return gl;

}

public boolean swap() {

mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);

return mEgl.eglGetError() != EGL11.EGL_CONTEXT_LOST;

}

public void finish() {

if (mEglSurface != null) {

mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE,

EGL10.EGL_NO_SURFACE,

EGL10.EGL_NO_CONTEXT);

mEgl.eglDestroySurface(mEglDisplay, mEglSurface);

mEglSurface = null;

}

if (mEglContext != null) {

mEgl.eglDestroyContext(mEglDisplay, mEglContext);

mEglContext = null;

}

if (mEglDisplay != null) {

mEgl.eglTerminate(mEglDisplay);

mEglDisplay = null;

}

}

}

class GLThread extends Thread {

private boolean mDone;

private boolean mPaused;

private boolean mHasFocus;

private boolean mHasSurface;

private boolean mContextLost;

private int mWidth;

private int mHeight;

private Renderer mRenderer;

private ArrayList

mEventQueue = new ArrayList();

private EglHelper mEglHelper;

GLThread(Renderer renderer) {

super();

mDone = false;

mWidth = 0;

mHeight = 0;

mRenderer = renderer;

setName("GLThread");

}

@Override

public void run() {

try {

try {

sEglSemaphore.acquire();

} catch (InterruptedException e) {

return;

}

guardedRun();

} catch (InterruptedException e) {

} finally {

sEglSemaphore.release();

}

}

private void guardedRun() throws InterruptedException {

mEglHelper = new EglHelper();

int[] configSpec = mRenderer.getConfigSpec();

mEglHelper.start(configSpec);

GL10 gl = null;

boolean tellRendererSurfaceCreated = true;

boolean tellRendererSurfaceChanged = true;

while (!mDone) {

int w, h;

boolean changed;

boolean needStart = false;

synchronized (this) {

Runnable r;

while ((r = getEvent()) != null) {

r.run();

}

if (mPaused) {

mEglHelper.finish();

needStart = true;

}

if(needToWait()) {

while (needToWait()) {

wait();

}

}

if (mDone) {

break;

}

changed = mSizeChanged;

w = mWidth;

h = mHeight;

mSizeChanged = false;

}

if (needStart) {

mEglHelper.start(configSpec);

tellRendererSurfaceCreated = true;

changed = true;

}

if (changed) {

gl = (GL10) mEglHelper.createSurface(mHolder);

tellRendererSurfaceChanged = true;

}

if (tellRendererSurfaceCreated) {

mRenderer.surfaceCreated(gl);

tellRendererSurfaceCreated = false;

}

if (tellRendererSurfaceChanged) {

mRenderer.sizeChanged(gl, w, h);

tellRendererSurfaceChanged = false;

}

if ((w > 0) && (h > 0)) {

mRenderer.drawFrame(gl);

mEglHelper.swap();

}

}

mEglHelper.finish();

}

private boolean needToWait() {

return (mPaused || (! mHasFocus) || (! mHasSurface) || mContextLost)

&& (! mDone);

}

public void surfaceCreated() {

synchronized(this) {

mHasSurface = true;

mContextLost = false;

notify();

}

}

public void surfaceDestroyed() {

synchronized(this) {

mHasSurface = false;

notify();

}

}

public void onPause() {

synchronized (this) {

mPaused = true;

}

}

public void onResume() {

synchronized (this) {

mPaused = false;

notify();

}

}

public void onWindowFocusChanged(boolean hasFocus) {

synchronized (this) {

mHasFocus = hasFocus;

if (mHasFocus == true) {

notify();

}

}

}

public void onWindowResize(int w, int h) {

synchronized (this) {

mWidth = w;

mHeight = h;

mSizeChanged = true;

}

}

public void requestExitAndWait() {

synchronized(this) {

mDone = true;

notify();

}

try {

join();

} catch (InterruptedException ex) {

Thread.currentThread().interrupt();

}

}

public void queueEvent(Runnable r) {

synchronized(this) {

mEventQueue.add(r);

}

}

private Runnable getEvent() {

synchronized(this) {

if (mEventQueue.size() > 0) {

return mEventQueue.remove(0);

}

}

return null;

}

}

}

本回答被网友采纳

已赞过

已踩过<

你对这个回答的评价是？

评论

收起

weixin_39904522
关注
android实现runnable接口,Android中实现Runnable接口简单例子
weixin_34393451的博客
06-01 2916
本课讲的是如何实现一个Runnable,在一个独立线程上运行Runnable.run()方法.Runnable对象执行特别操作有时叫作任务。Thread和Runnable都是基础的类，靠他们自己，能力有限。作为替代，Android有强大的基础类，像HandlerThread，AsyncTask，IntentService。Thread和Runnable也是ThreadPoolExecutor的基础...
android handler runnable使用实例(关键是内部run中停止)
03-12
android handler runnable使用实例(关键是内部run中停止)
androidrunnable使用_Android 之神奇的 Runnable 对象
weixin_39533361的博客
12-22 939
回顾一下我们之前的 开启一个线程Thread并用进度条显示进度 小节，提到了这么一个东西：不允许在 WorkerThread 中去修改 UI，要修改 UI 只能通过在 WorkerThread 中用 Handler 将数据发送到消息队列中，然后在主线程用 Looper(就是在主线程中实例化 Handler) 将数据从消息队列中取出，才能修改 UI。那么，我们现在再来看看这么一个例子，会颠覆之前的看...
Java多线程编程-线程安全和锁Synchronized概念
Jaemon
12-03 248
Java多线程编程-线程安全和锁Synchronized概念
Android Runnable 用法
热门推荐
michaelpp的专栏
06-30 1万+
<br />从Runnable派生你的子类，重载run()方法。<br />然后调用View.post(myRunnableObj)即可把你的Runnable对象增加到UI线程中运行。<br /> <br />boolean android.view.View .post(Runnable action)<br />Causes the Runnable to be added to the message queue. The runnable will be run on the user
androidrunnable使用_android handler.post(Runnable)
weixin_28922555的博客
12-31 478
package com.android;import android.app.Activity;import android.content.Context;import android.graphics.Canvas;import android.graphics.Color;import android.graphics.Paint;import android.os.Bundle;impor...
Android中实现Runnable接口简单例子
01-05
本课讲的是如何实现一个Runnable,在一个独立线程上运行Runnable.run()方法.Runnable对象执行特别操作有时叫作任务。 Thread和Runnable都是基础的类，靠他们自己，能力有限。作为替代，Android有强大的基础类，像...
a-TetrisGame_俄罗斯方块_androidstudio_android_源码
10-02
使用Android Studio内置的模拟器或连接真实设备进行测试，找出并修复游戏中的bug，保证游戏的稳定性和流畅性。 10. Gradle构建系统： Android Studio使用Gradle作为构建工具，它允许开发者灵活地管理依赖关系，...
android实现runnable接口,013 Android多线程-实现Runnable接口
weixin_34395361的博客
06-01 645
目录image1. 简介image2. 使用讲解2.1 使用步骤image特别注意：Java中真正能创建新线程的只有Thread类对象通过实现Runnable的方式，最终还是通过Thread类对象来创建线程所以对于 实现了Runnable接口的类，称为 线程辅助类；Thread类才是真正的线程类2.2 具体使用// 步骤1：创建线程辅助类，实现Runnable接口class MyThread im...
Android 多线程下载简单demo之Runnable
08-04
简单的demo,对应的我的博客地址是http://blog.csdn.net/u012320459/article/details/47271319
android中的线程机制（一）————Runnable
weixin_34308389的博客
10-21 110
1、声明机制 // 单个线程机制测试 private Handler mHandler; Runnable mBackgroundRunnable; private boolean mRunning = true; 2、在Oncreate()中启动 //单个线程机制测试 HandlerThread thread = new Handl...
android开发之多线程编程Thread和Runnable使用
chm880910的专栏
04-14 492
Android有两种方式实现多线程，一种是继承Thread类，覆写run()方法。一种是实现Runnable接口，再用该实现创建Thread。第一种方式：Java中一个类只能继承一个父类，该方式的局限性所在。package com.vixtel.tools; public class SyncThread extends Thread { @Override ...
Android——Runnable和Thread，进阶：Callable接口 / Runnable接口 / Future接口
Yawn
06-09 2471
1. 简介 为什么要有，Callable接口和Runnable接口? 我们知道创建线程的方式有两种，一种是实现Runnable接口，另一种是继承Thread，但是这两种创建线程的方式都有个问题，执行完任务后无法获取返回结果，于是，就有了Callable接口和Runnable接口。 看看创建线程的两个方法： Class MyThread extends Thread{ @Override Void run(){ } } new MyThread().start(); Cla
androidrunnable使用_Android的：如何停止的Runnable？
weixin_39959236的博客
12-22 914
I tried this way:private Runnable changeColor = new Runnable() {private boolean killMe=false;public void run() {//some workif(!killMe) color_changer.postDelayed(changeColor, 150);}public void kill(){k...
Android Runnable 运行在那个线程
蝈蝈俊.net
05-06 8775
Runnable 并不一定是新开一个线程，比如下面的调用方法就是运行在UI主线程中的： Handler mHandler=new Handler(); mHandler.post(new Runnable(){ @Override public void run() { // TODO Auto-generated method stub } }); 官方对这个方法的解释如下，注意其中的：“The runnable will be run on the user in
Android多线程：继承Thread类、实现Runnable接口使用教程(含实例讲解)
Carson带你学Android
05-30 9632
前言 在Android开发中，多线程的使用十分常见 今天，我将全面解析多线程中最常见的2种用法：继承Thread类 &amp;amp; 实现Runnable接口 含丰富的实例讲解，切记不能错过。 Part 1：继承Thread类 目录 1. 简介 2. 使用讲解 2.1 使用步骤 2.2 具体使用 ...
Android多线程：实现Runnable接口 使用解析（含实例教程）
爱生活
06-04 627
原文：https://www.jianshu.com/p/95b186fbf192
Android开发：使用Runnable和Handler创建UI友好型定时器
"运行计时器-powerworld...要在Android应用中实现计时器，开发者需要理解线程管理，特别是如何使用`Runnable`和`Handler`避免主线程阻塞。同时，对于初学者，熟悉Android Studio的基本操作和Java编程基础是至关重要的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值