android surfaceview 多线程绘图

在 Android 中，如果需要同时进行多个子线程的绘图操作，可以使用 SurfaceView 的双缓冲机制来避免绘图的冲突和重复。下面是一个简单的示例代码：

首先，在布局文件中添加 SurfaceView：

<SurfaceView
    android:id="@+id/surfaceView"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

然后，在 Activity 中获取 SurfaceView 对象，并在其上创建多个子线程进行绘图：

public class MyActivity extends Activity implements SurfaceHolder.Callback {
    private SurfaceView mSurfaceView;
    private SurfaceHolder mSurfaceHolder;
    private DrawThread[] mDrawThreads;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);

        // 获取 SurfaceView 对象和 SurfaceHolder 对象
        mSurfaceView = findViewById(R.id.surfaceView);
        mSurfaceHolder = mSurfaceView.getHolder();

        // 设置 SurfaceHolder.Callback
        mSurfaceHolder.addCallback(this);

        // 创建多个子线程
        mDrawThreads = new DrawThread[4];
        for (int i = 0; i < mDrawThreads.length; i++) {
            mDrawThreads[i] = new DrawThread(mSurfaceHolder, i);
        }
    }

    // SurfaceHolder.Callback 的实现
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // 启动多个子线程
        for (DrawThread thread : mDrawThreads) {
            thread.start();
        }
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        // do nothing
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // 停止多个子线程
        for (DrawThread thread : mDrawThreads) {
            thread.stopDrawing();
        }
    }

    // 子线程
    private class DrawThread extends Thread {
        private SurfaceHolder mSurfaceHolder;
        private boolean mIsDrawing = true;
        private int mThreadId;

        public DrawThread(SurfaceHolder surfaceHolder, int threadId) {
            mSurfaceHolder = surfaceHolder;
            mThreadId = threadId;
        }

        public void stopDrawing() {
            mIsDrawing = false;
        }

        @Override
        public void run() {
            while (mIsDrawing) {
                // 获取 Canvas 对象，使用双缓冲机制
                Canvas canvas = mSurfaceHolder.lockCanvas();
                if (canvas != null) {
                    // 在 Canvas 上进行绘图操作
                    // ...

                    // 解锁 Canvas
                    mSurfaceHolder.unlockCanvasAndPost(canvas);
                }
            }
        }
    }
}

在上面的示例代码中，我们创建了多个 DrawThread 对象，并在 surfaceCreated() 方法中启动这些子线程。在子线程中，我们使用双缓冲机制来避免绘图的冲突和重复。具体来说，我们使用 SurfaceHolder 的 lockCanvas() 方法获取 Canvas 对象，并在 Canvas 上进行绘图操作。然后，在解锁 Canvas 之前，我们先使用 SurfaceHolder 的 lockCanvas() 方法再次获取 Canvas 对象，并在这个新的 Canvas 对象上进行绘图操作。最后，我们再解锁原来的 Canvas 对象，这样就可以避免绘图的冲突和重复了。

注意，在使用双缓冲机制时，需要使用每个子线程独立的缓冲区，并且在绘图操作完成后，需要重新绘制整个 SurfaceView。