Android Handler的使用二

最新推荐文章于 2025-07-28 14:40:39 发布
转载 最新推荐文章于 2025-07-28 14:40:39 发布 · 434 阅读 · 0
文章标签：

#Android #线程 #handler

本文详细介绍了 Android 中 Handler 的五种使用方法，包括消息处理队列的绑定方式、消息的发送和接收过程，以及如何实现主子线程间的双向消息传递。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

2、sendMessage版本的Handler的使用

a、默认的Handler（消息处理队列挂在主线程上）

package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

public class MainActivity extends Activity
				  implements OnClickListener {
	private final static String TAG = "HandlerTest";
	
	private final static int TASK_BEGIN	= 1;
	private final static int TASK_1	= 2;
	private final static int TASK_2	= 3;
	private final static int TASK_END	= 4;
	
	private Button btnStart = null;
	private Button btnStop = null;
	
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        btnStart = (Button) findViewById(R.id.btn_start);
        btnStart.setOnClickListener(this);
        btnStop = (Button) findViewById(R.id.btn_stop);
        btnStop.setOnClickListener(this);
        
        Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]");
    }
    
    Handler mHandler = new Handler() {
    	// 注意：在各个case后面不能做太耗时的操作，否则出现ANR对话框
    	@Override
    	public void handleMessage(Message msg) {
    		switch (msg.what) {
    		case TASK_BEGIN:
    			Log.i(TAG, "[H_TID:" +
    				Thread.currentThread().getId() + "] Get TASK_BEGIN");
    			break;
    			
    		case TASK_1:
    			Log.i(TAG, "[H_TID:" +
    				Thread.currentThread().getId() + "] Get TASK_1");
    			break;
    			
    		case TASK_2:
    			Log.i(TAG, "[H_TID:" +
    				Thread.currentThread().getId() + "] Get TASK_2");
    			break;
    			
    		case TASK_END:
    			Log.i(TAG, "[H_TID:" +
    				Thread.currentThread().getId() + "] Get TASK_END");
    			finish();
    			break;
    		}
    		super.handleMessage(msg);
    	}
    };
    
    public void onClick(View view) {
    	switch (view.getId()) {
    	case R.id.btn_start:
    		// 启动任务（消息只有标识，立即投递）
    		mHandler.sendEmptyMessage(TASK_BEGIN);
    		Log.i(TAG, "Send TASK_BEGIN to handler.");
    		
    		// 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）
    		Message msg1 = mHandler.obtainMessage(TASK_1);
    		msg1.obj = "This is task1";
    		mHandler.sendMessage(msg1);
    		Log.i(TAG, "Send TASK_1 to handler.");
    		
    		// 开启任务2（和上面类似）
    		Message msg2 = Message.obtain();
    		msg2.arg1 = 10;
    		msg2.arg2 = 20;
    		msg2.what = TASK_2;
    		mHandler.sendMessage(msg2);
    		Log.i(TAG, "Send TASK_2 to handler.");
    		break;
    		
    	case R.id.btn_stop:
    		// 结束任务（空消息体，延时2s投递）
    		mHandler.sendEmptyMessageDelayed(TASK_END, 2000);
    		Log.i(TAG, "Send TASK_END to handler.");
    		break;
    	}
}
}
运行结果：


b、消息队列仍绑定在主线程上，但在子线程中发送消息。


package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
	private final static String TAG = "HandlerTest";
	
	private final static int TASK_BEGIN	= 1;
	private final static int TASK_1	= 2;
	private final static int TASK_2	= 3;
	private final static int TASK_END	= 4;
	
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
        		"This is in main thread.");
        
        workThread.start();
    }
    
    Handler mHandler = new Handler() {
    	// 注意：在各个case后面不能做太耗时的操作，否则出现ANR对话框
    	@Override
    	public void handleMessage(Message msg) {
    		switch (msg.what) {
    		case TASK_BEGIN:
    			Log.i(TAG, "[H_TID:" +
				Thread.currentThread().getId() + "] Get TASK_BEGIN");
    			break;
    			
    		case TASK_1:
    			Log.i(TAG, "[H_TID:" +
				Thread.currentThread().getId() + "] Get TASK_1");
    			break;
    			
    		case TASK_2:
    			Log.i(TAG, "[H_TID:" +
				Thread.currentThread().getId() + "] Get TASK_2");
    			break;
    			
    		case TASK_END:
    			Log.i(TAG, "[H_TID:" +
				Thread.currentThread().getId() + "] Get TASK_END");
    			finish();
    			break;
    		}
    		super.handleMessage(msg);
    	}
    };
    
    Thread workThread = new Thread() {
    	// 你可以在run方法内做任何耗时的操作，然后将结果以消息形式投递到主线程的消息队列中
    	@Override
    	public void run() {
    		// 启动任务（消息只有标识，立即投递）
    		mHandler.sendEmptyMessage(TASK_BEGIN);
    		Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +
    				"Send TASK_START to handler.");
    		
    		// 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）
    		Message msg1 = mHandler.obtainMessage(TASK_1);
    		msg1.obj = "This is task1";
    		mHandler.sendMessage(msg1);
    		Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +
    				"Send TASK_1 to handler.");
    		
    		// 开启任务2（和上面类似）
    		Message msg2 = Message.obtain();
    		msg2.arg1 = 10;
    		msg2.arg2 = 20;
    		msg2.what = TASK_2;
    		mHandler.sendMessage(msg2);
    		Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +
    				"Send TASK_2 to handler.");
    		
    		// 结束任务（空消息体，延时2s投递）
    		mHandler.sendEmptyMessageDelayed(TASK_END, 2000);
    		Log.i(TAG, "[S_TID:" + Thread.currentThread().getId() + "]" +
    				"Send TASK_END to handler.");
    	}
    };
}
运行结果：


c、将消息队列绑定到子线程上，主线程只管通过Handler往子线程的消息队列中投递消息即可。


package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
	private final static String TAG = "HandlerTest";
	
	private final static int TASK_BEGIN	= 1;
	private final static int TASK_1	= 2;
	private final static int TASK_2	= 3;
	private final static int TASK_END	= 4;
	
	private MyHandler mHandler = null;
	
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
        		"This is in main thread.");
        
        HandlerThread myLooperThread = new HandlerThread("my looper thread");
        myLooperThread.start();
        
        Looper looper = myLooperThread.getLooper();
        mHandler = new MyHandler(looper);
        
        // 启动任务（消息只有标识，立即投递）
		mHandler.sendEmptyMessage(TASK_BEGIN);
		Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_START to handler.");
		
		// 开始任务1（在mHandler的消息队列中获取一个Message对象，避免重复构造）
		Message msg1 = mHandler.obtainMessage(TASK_1);
		msg1.obj = "This is task1";
		mHandler.sendMessage(msg1);
		Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_1 to handler.");
		
		// 开启任务2（和上面类似）
		Message msg2 = Message.obtain();
		msg2.arg1 = 10;
		msg2.arg2 = 20;
		msg2.what = TASK_2;
		mHandler.sendMessage(msg2);
		Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_2 to handler.");
		
		// 结束任务（空消息体，延时2s投递）
		mHandler.sendEmptyMessageDelayed(TASK_END, 2000);
		Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_END to handler.");
    }
    
    class MyHandler extends Handler {
    	public MyHandler(Looper looper) {
    		super(looper);
    	}
    	
    	// 现在在每个case之后，你可以做任何耗时的操作了
    	@Override
    	public void handleMessage(Message msg) {
    		switch (msg.what) {
    		case TASK_BEGIN:
    			Log.i(TAG, "[H_TID:" +
    				Thread.currentThread().getId() + "] Get TASK_BEGIN");
    			break;
    			
    		case TASK_1:
    			Log.i(TAG, "[H_TID:" +
    				Thread.currentThread().getId() + "] Get TASK_1");
    			break;
    			
    		case TASK_2:
    			Log.i(TAG, "[H_TID:" +
    				Thread.currentThread().getId() + "] Get TASK_2");
    			break;
    			
    		case TASK_END:
    			Log.i(TAG, "[H_TID:" +
    				Thread.currentThread().getId() + "] Get TASK_END");
    			finish();
    			break;
    		}
    		super.handleMessage(msg);
    	}
    }
}

运行结果：



d、自己创建新的线程，然后在新线程中创建Looper，主线程调用子线程中的发消息方法，将消息发给子线程的消息队列。



package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
	private final static String TAG = "HandlerTest";
	
	private final static int TASK_BEGIN	= 1;
	private final static int TASK_1	= 2;
	private final static int TASK_2	= 3;
	private final static int TASK_END	= 4;
	
	private Handler workHandler = null;
	
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
        		"This is in main thread.");
        
        LooperThread testThread = new LooperThread();
        testThread.start();
        
        // 注意，这里需要等待一下，防止出现空指针异常
        while (null == workHandler) {
        }
        
        testThread.sendMessageTodoYourWork();
    }
    
    class LooperThread extends Thread {
    	@Override
    	public void run() {
    		Looper.prepare();
    		
    		workHandler = new Handler() {
    			// 现在在每个case之后，你可以做任何耗时的操作了
    	    	@Override
    	    	public void handleMessage(Message msg) {
    	    		switch (msg.what) {
    	    		case TASK_BEGIN:
    	    			Log.i(TAG, "[H_TID:" +
    	    			   Thread.currentThread().getId() + "] Get TASK_BEGIN");
    	    			break;
    	    			
    	    		case TASK_1:
    	    			Log.i(TAG, "[H_TID:" +
    	    			   Thread.currentThread().getId() + "] Get TASK_1");
    	    			break;
    	    			
    	    		case TASK_2:
    	    			Log.i(TAG, "[H_TID:" +
    	    			   Thread.currentThread().getId() + "] Get TASK_2");
    	    			break;
    	    			
    	    		case TASK_END:
    	    			Log.i(TAG, "[H_TID:" +
    	    			   Thread.currentThread().getId() + "] Get TASK_END");
    	    			Looper.myLooper().quit();
    	    			finish();
    	    			break;
    	    		}
    	    		super.handleMessage(msg);
    	    	}
    		};
    		
    		Looper.loop();
    	}
    	
    	public void sendMessageTodoYourWork() {
    		Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_START to handler.");
    		// 启动任务（消息只有标识，立即投递）
    		workHandler.sendEmptyMessage(TASK_BEGIN);

    		Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_1 to handler.");
    		// 开始任务1（在workHandler的消息队列中获取一个Message对象，避免重复构造）
    		Message msg1 = workHandler.obtainMessage(TASK_1);
    		msg1.obj = "This is task1";
    		workHandler.sendMessage(msg1);
    		
    		Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_2 to handler.");    		
    		// 开启任务2（和上面类似）
    		Message msg2 = Message.obtain();
    		msg2.arg1 = 10;
    		msg2.arg2 = 20;
    		msg2.what = TASK_2;
    		workHandler.sendMessage(msg2);

    		Log.i(TAG, "[S_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_END to handler.");
    		// 结束任务（空消息体，延时2s投递）
    		workHandler.sendEmptyMessageDelayed(TASK_END, 2000);
    	}
    }
}

运行结果：



e、主/子线程均有一个消息队列，然后相互传递消息（这种方式是最灵活的，双向传递，也不复杂）


package com.dxyh.test;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.Message;
import android.util.Log;

public class MainActivity extends Activity {
	private final static String TAG = "HandlerTest";
	
	private final static int TASK_BEGIN		= 1;
	private final static int TASK_1		= 2;
	private final static int TASK_2		= 3;
	private final static int TASK_END		= 4;
	
	private final static int TASK_BEGIN_OVER	= 11;
	private final static int TASK_1_OVER	= 12;
	private final static int TASK_2_OVER	= 13;
	private final static int TASK_END_OVER	= 14;
	
	private Handler workHandler = null;
	
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        Log.i(TAG, "[M_TID:" + Thread.currentThread().getId() + "]" +
        		"This is in main thread.");
        
        LooperThread testThread = new LooperThread();
        testThread.start();
        
        // 注意，这里需要等待一下，防止出现空指针异常
        while (null == workHandler) {
        }
        
        testThread.sendMessageTodoYourWork();
    }
  
    Handler mainHandler = new Handler () {
    	// 在每个case之后，不能做耗时的操作
    	@Override
    	public void handleMessage(Message msg) {
    		switch (msg.what) {
    		case TASK_BEGIN_OVER:
    			Log.i(TAG, "[MH_TID:" +
    				Thread.currentThread().getId() + "] TASK_BEGIN_OVER");
    			break;
    			
    		case TASK_1_OVER:
    			Log.i(TAG, "[MH_TID:" +
    				Thread.currentThread().getId() + "] TASK_1_OVER");
    			break;
    			
    		case TASK_2_OVER:
    			Log.i(TAG, "[MH_TID:" +
    				Thread.currentThread().getId() + "] TASK_2_OVER");
    			break;
    			
    		case TASK_END_OVER:
    			Log.i(TAG, "[MH_TID:" +
    				Thread.currentThread().getId() + "] TASK_END_OVER");
    			finish();
    			break;
    		}
    		super.handleMessage(msg);
    	}
    };
    
    class LooperThread extends Thread {
    	@Override
    	public void run() {
    		Looper.prepare();
    		
    		workHandler = new Handler() {
    			// 现在在每个case之后，你可以做任何耗时的操作了
    	    	@Override
    	    	public void handleMessage(Message msg) {
    	    		switch (msg.what) {
    	    		case TASK_BEGIN:
    	    			Log.i(TAG, "[ZH_TID:" +
    	    			   Thread.currentThread().getId() + "] Get TASK_BEGIN");
    	    			// 做完之后报告信息给主线程
    	    			mainHandler.sendEmptyMessage(TASK_BEGIN_OVER);
    	    			break;
    	    			
    	    		case TASK_1:
    	    			Log.i(TAG, "[ZH_TID:" +
    	    			   Thread.currentThread().getId() + "] Get TASK_1");
    	    			// 做完之后报告信息给主线程
    	    			mainHandler.sendEmptyMessage(TASK_1_OVER);
    	    			break;
    	    			
    	    		case TASK_2:
    	    			Log.i(TAG, "[ZH_TID:" +
    	    			   Thread.currentThread().getId() + "] Get TASK_2");
    	    			// 做完之后报告信息给主线程
    	    			mainHandler.sendEmptyMessage(TASK_2_OVER);
    	    			break;
    	    			
    	    		case TASK_END:
    	    			Log.i(TAG, "[ZH_TID:" +
    	    			   Thread.currentThread().getId() + "] Get TASK_END");
    	    			Looper.myLooper().quit();
    	    			// 做完之后报告信息给主线程
    	    			mainHandler.sendEmptyMessage(TASK_END_OVER);
    	    			Looper.myLooper().quit();
    	    			break;
    	    		}
    	    		super.handleMessage(msg);
    	    	}
    		};
    		
    		Looper.loop();
    	}
    	
    	public void sendMessageTodoYourWork() {
    		Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_START to handler.");
    		// 启动任务（消息只有标识，立即投递）
    		workHandler.sendEmptyMessage(TASK_BEGIN);

    		Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_1 to handler.");
    		// 开始任务1（在workHandler的消息队列中获取一个Message对象，避免重复构造）
    		Message msg1 = workHandler.obtainMessage(TASK_1);
    		msg1.obj = "This is task1";
    		workHandler.sendMessage(msg1);
    		
    		Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_2 to handler.");    		
    		// 开启任务2（和上面类似）
    		Message msg2 = Message.obtain();
    		msg2.arg1 = 10;
    		msg2.arg2 = 20;
    		msg2.what = TASK_2;
    		workHandler.sendMessage(msg2);

    		Log.i(TAG, "[ZS_ID:" + Thread.currentThread().getId() + "]" +
				"Send TASK_END to handler.");
    		// 结束任务（空消息体，延时2s投递）
    		workHandler.sendEmptyMessageDelayed(TASK_END, 2000);
    	}
    }
}

运行结果：


 小结：Handler在Android中是很常用的，或是用来更新UI，或是派发任务给子线程去执行，也可以用来产生超时效果，比如用sendMessageDelayed(TASK_TIMEOUT, OUT_TIME)方法。



Button点击事件的常用实现方式
铁铮的博客
07-18 1984
1.内部类中实现点击监听器（适用多Button） 1.Button btn = (Button)findViewById(R.id.btn); 2.btn.setOnClickListener(new MyOnClickListener()); 3.在MainActivity中创建内部类 class MyOnClickLisener implements OnClickListener{ public void onClick(View v){ //具体功能
android的handler使用方法,Android Handler使用方法
weixin_42120283的博客
05-27 1615
目录：目录1. 前言本篇文章介绍 Android Handler 的基本使用方法，且 Demo 会以 Java & Kotlin 两种代码形式进行展示。在 Android 实际开发中，我们经常会遇到耗时任务，比如：网络请求API接口来获取数据、数据库 CRUD 操作等等，我们需要额外创建开启工作线程来处理这些耗时任务。由于 Android 规定只能由主线程才能处理 UI 工作，所以这时候我...
已解决：错误: 找不到符号button = (Button)findViewById(R.id.button)；
THMAIL的博客
12-30 6249
看了好几篇文章，不说人话，瞎几把扯，最后自己解决了。 问题原因：我们的布局文件没有button这个组件（我的是button不存在，你们看你们自己的是哪一个）； 解决办法：打开app/src/main/res/layout/，下面有一个.xml格式的布局文件，打开它然后在palette窗口找到你报错的组件，拖动到图形界面中，ctrl+s保存，然后重新run即可 ...
Android Handler 的基本使用
龚建波
08-04 2748
Handler 允许你发送和处理与线程的 MessageQueue 关联的 Message 和 Runnable 对象。 每个 Handler 实例都与一个线程和该线程的消息队列 (MessageQueue) 相关联。 当你创建一个新的 Handler 时，它会绑定到 Looper。 它将向 Looper 的消息队列传递消息 (Message) 和可运行对象 (Runnable)，并在 Looper 的线程上执行它们。
Android Handler使用介绍
小旭的专栏
03-21 3211
Android 中的 Handler 是用来和线程通信的重要工具。它主要用于在后台线程中执行任务，并将结果传递回主线程以更新用户界面。
Android Handler 完全指南
weixin_37794278的博客
07-28 1064
本文深入解析Android开发中Handler的核心机制与应用场景。作为线程通信的关键工具，Handler实现了子线程与主线程的安全交互，支持TCP通信、UI更新等关键功能。文章首先剖析了Handler的消息循环原理，包括Message、MessageQueue、Looper的协同工作机制；随后通过TCP通信实战案例，展示如何定义消息类型、处理延迟任务；针对内存泄漏、消息丢失等常见问题，提供了静态内部类+弱引用等解决方案；最后对比了Handler与协程等替代方案，并总结了最佳实践。全文强调Handler作为
Android Handler 使用详解
u012841414的博客
10-21 3703
是一个消息分发对象，进行发送和处理消息，并且其 Runnable 对象与一个线程的 MessageQueue 关联。：调度消息，将一个任务切换到某个指定的线程中去执行。
android handler的使用
qq_54038326的博客
10-27 1311
handler
【Android】Handler 使用
微信公众号: 后端码匠
11-20 1648
Android中的消息机制是通过Handler来实现的。随着EventBus和RxJava等依托观察者模式的消息传递机制的出现，当前在Android开发中Handler的使用已经不如之前那么重要，但是Android系统所提供的Handler中的各种编程思路和设计方案，对我们在编程思想的提升还是有很大益处的。
Android Handler用法
Watom_663的博客
04-29 2409
Android UI操作并非线程安全。因此，请不要在工作线程(即子线程)中操纵界面。您可以通过界面线程对界面进行所有操作。
详解Android中Handler的使用方法
01-04
在Android开发中，我们经常会遇到这样一种情况：在UI界面上进行某项操作后要执行一段很耗时的代码，比如我们在界面上点击了一个”下载“按钮，那么我们需要执行网络请求，这是一个耗时操作，因为不知道什么时候才能...
android Handler详细使用方法实例
01-04
开发环境为android4.1.Handler使用例1这个例子是最简单的介绍handler使用的,是将handler绑定到它所建立的线程中.本次实验完成的功能是:单击Start按钮，程序会开始启动线程，并且线程程序完成后延时1s会继续启动该...
Android 异步任务 设置 超时使用handler更新通知功能
08-28
"Android 异步任务 设置 超时使用Handler更新通知功能" Android 异步任务 设置 超时使用Handler更新通知功能是 Android 开发中的一种常见问题，主要介绍了使用AsyncTask设置请求超时的注意事项，并使用Handler更新...
基于SSM的一线式酒店管理系统-su0v7503【附万字论文+PPT+包部署+录制讲解视频】.zip
最新发布
08-15
基于SSM的一线式酒店管理系统-su0v7503【附万字论文+PPT+包部署+录制讲解视频】.zip
STM32F4高级定时器定时器应用示例代码
08-15
STM32F4高级定时器定时器应用示例代码
【python毕业设计】基于数据挖掘的音乐推荐系统(django)（完整项目源码+mysql+说明文档）.zip
08-15
基于数据挖掘的音乐推荐系统设计与实现 需要一个代码说明，不需要论文 采用python语言，django框架，mysql数据库开发 编程环境：pycharm，mysql8.0 系统分为前台+后台模式开发 网站前台： 用户注册， 登录 搜索音乐，音乐欣赏（可以在线进行播放） 用户登陆时选择相关感兴趣的音乐风格 音乐收藏 音乐推荐算法：（重点） 本课题需要大量用户行为（如播放记录、收藏列表）、音乐特征（如音频特征、歌曲元数据）等数据 （1）根据用户之间相似性或关联性，给一个用户推荐与其相似或有关联的其他用户所感兴趣的音乐； （2）根据音乐之间的相似性或关联性，给一个用户推荐与其感兴趣的音乐相似或有关联的其他音乐。 基于用户的推荐和基于物品的推荐 其中基于用户的推荐是基于用户的相似度找出相似相似用户，然后向目标用户推荐其相似用户喜欢的东西（和你类似的人也喜欢**东西）； 而基于物品的推荐是基于物品的相似度找出相似的物品做推荐（喜欢该音乐的人还喜欢了**音乐）； 管理员 管理员信息管理 注册用户管理，审核 音乐爬虫（爬虫方式爬取网站音乐数据） 音乐信息管理（上传歌曲MP3，以便前台播放） 音乐收藏管理 用户 用户资料修改 我的音乐收藏 完整前后端源码，部署后可正常运行！ 环境说明 开发语言：python后端 python版本：3.7 数据库：mysql 5.7+ 数据库工具：Navicat11+ 开发软件：pycharm
MPU6050.zip
08-15
MPU6050是一款广泛应用在无人机、机器人和运动设备中的六轴姿态传感器，它集成了三轴陀螺仪和三轴加速度计。这款传感器能够实时监测并提供设备的角速度和线性加速度数据，对于理解物体的动态运动状态至关重要。在Arduino平台上，通过特定的库文件可以方便地与MPU6050进行通信，获取并解析传感器数据。 `MPU6050.cpp`和`MPU6050.h`是Arduino库的关键组成部分。`MPU6050.h`是头文件，包含了定义传感器接口和函数声明。它定义了类`MPU6050`，该类包含了初始化传感器、读取数据等方法。例如，`begin()`函数用于设置传感器的工作模式和I2C地址，`getAcceleration()`和`getGyroscope()`则分别用于获取加速度和角速度数据。 在Arduino项目中，首先需要包含`MPU6050.h`头文件，然后创建`MPU6050`对象，并调用`begin()`函数初始化传感器。之后，可以通过循环调用`getAcceleration()`和`getGyroscope()`来不断更新传感器读数。为了处理这些原始数据，通常还需要进行校准和滤波，以消除噪声和漂移。 I2C通信协议是MPU6050与Arduino交互的基础，它是一种低引脚数的串行通信协议，允许多个设备共享一对数据线。Arduino板上的Wire库提供了I2C通信的底层支持，使得用户无需深入了解通信细节，就能方便地与MPU6050交互。 MPU6050传感器的数据包括加速度（X、Y、Z轴）和角速度（同样为X、Y、Z轴）。加速度数据可以用来计算物体的静态位置和动态运动，而角速度数据则能反映物体转动的速度。结合这两个数据，可以进一步计算出物体的姿态（如角度和角速度变化）。 在嵌入式开发领域，特别是使用STM32微控制器时，也可以找到类似的库来驱动MPU6050。STM32通常具有更强大的处理能力和更多的GPIO口，可以实现更复杂的控制算法。然而，基本的传感器操作流程和数据处理原理与Arduino平台相似。 在实际应用中，除了基本的传感器读取，还可能涉及到温度补偿、低功耗模式设置、DMP（数字运动处理器）功能的利用等高级特性。DMP可以帮助处理传感器数据，实现更高级的运动估计，减轻主控制器的计算负担。 MPU6050是一个强大的六轴传感器，广泛应用于各种需要实时运动追踪的项目中。通过 Arduino 或 STM32 的库文件，开发者可以轻松地与传感器交互，获取并处理数据，实现各种创新应用。博客和其他开源资源是学习和解决问题的重要途径，通过这些资源，开发者可以获得关于MPU6050的详细信息和实践指南
【python毕业设计】通用排课系统(django)（完整项目源码+mysql+说明文档+LW+PPT）.zip
08-15
对于学生端，核心需求在于能够轻松访问并管理自己的课程表[8]。学生需要能够方便地完成注册、登录，并查看专属于自己的课程详细信息，包括不限于时间、地点、教师等。系统应支持当课程表中任何课程时间发生变动，需要及时在系统内进行更新，保障课程信息的时效性。 教师端的功能需求主要集中在课程表的查看和管理。教师与学生一样，同样需要能够方便地查看自己的教学课表，了解课程时间、地点和相关学生班级信息。系统应允许教师接收课程安排的更新通知，并查看学生的出勤情况，以便及时跟进学生的课程进展。 管理员的功能需求主要集中在课程维护和用户管理。管理员负责管理用户的权限设置，包括教师和学生的账户管理。与此同时，管理员负责监控系统的性能和安全状态，并执行必要的系统升级和维护。管理员重点需要管理课程信息、班级信息，并进行教室分配和课程表生成，确保系统功能的正常运行，满足教师和学生的日常使用需求。 完整前后端源码，部署后可正常运行！ 环境说明 开发语言：python后端 python版本：3.7 数据库：mysql 5.7+ 数据库工具：Navicat11+ 开发软件：pycharm
nctoolbox20121106用于matlab读取GRIB数据
08-15
nctoolbox20121106用于matlab读取GRIB数据
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值