1 前言

​ 纹理贴图 中介绍了将矩形图片贴到矩形模型上，本文将介绍：在不裁剪图片的情况下，将正方形的图片贴到圆形模型上。

​ 思考：实数区间 [0, 1] 与 [0, 2] 的元素可以建立一一映射关系么？答案是肯定的，如：y=2x、y=2x2、y=2*ex/e^2、y=2ln(x+1)/ln2、y=2sin(π/2*x) 等等，其中 x∈[0, 1]，y∈[0, 2]。

​ 同理，在二维平面上，也可以构造一个函数，使得正方形上的点与圆形上的点一一对应。映射的构建如下图：

​ 原图如下：

​ 映射如下：

​

​ 读者如果对 OpenGL ES 不太熟悉，请回顾以下内容：

​ 本文完整代码资源见→【OpenGL ES】正方形图片贴到圆形上

​ 项目目录如下：

2 案例

​ MainActivity.java

  1. package com.zhyan8.squaretocircle.activity;
  3. import android.opengl.GLSurfaceView;
  4. import android.os.Bundle;
  5. import androidx.appcompat.app.AppCompatActivity;
  6. import com.zhyan8.squaretocircle.opengl.MyGLSurfaceView;
  7. import com.zhyan8.squaretocircle.opengl.MyRender;
  9. public class MainActivity extends AppCompatActivity {
  10.     private GLSurfaceView mGlSurfaceView;
  12.     @Override
  13.     protected void onCreate(Bundle savedInstanceState) {
  14.         super.onCreate(savedInstanceState);
  15.         mGlSurfaceView = new MyGLSurfaceView(this);
  16.         setContentView(mGlSurfaceView);
  17.         mGlSurfaceView.setRenderer(new MyRender(this));
  18.     }
  20.     @Override
  21.     protected void onResume() {
  22.         super.onResume();
  23.         mGlSurfaceView.onResume();
  24.     }
  26.     @Override
  27.     protected void onPause() {
  28.         super.onPause();
  29.         mGlSurfaceView.onPause();
  30.     }
  31. }

​ MyGLSurfaceView.java

  1. package com.zhyan8.squaretocircle.opengl;
  3. import android.content.Context;
  4. import android.opengl.GLSurfaceView;
  5. import android.util.AttributeSet;
  7. public class MyGLSurfaceView extends GLSurfaceView {
  8.     public MyGLSurfaceView(Context context) {
  9.         super(context);
  10.         setEGLContextClientVersion(3);
  11.     }
  13.     public MyGLSurfaceView(Context context, AttributeSet attrs) {
  14.         super(context, attrs);
  15.         setEGLContextClientVersion(3);
  16.     }
  17. }

​ MyRender.java

  1. package com.zhyan8.squaretocircle.opengl;
  3. import android.content.Context;
  4. import android.opengl.GLES30;
  5. import android.opengl.GLSurfaceView;
  6. import com.zhyan8.squaretocircle.model.Model;
  7. import javax.microedition.khronos.egl.EGLConfig;
  8. import javax.microedition.khronos.opengles.GL10;
  10. public class MyRender implements GLSurfaceView.Renderer {
  11.     private Context mContext;
  12.     private Model mModel;
  13.     private int mProgramId;
  15.     public MyRender(Context context) {
  16.         mContext = context;
  17.         mModel = new Model();
  18.     }
  20.     @Override
  21.     public void onSurfaceCreated(GL10 gl, EGLConfig eglConfig) {
  22.         //设置背景颜色
  23.         GLES30.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  24.         //创建程序id
  25.         mProgramId = mModel.onModelCreate(mContext.getResources());
  26.         GLES30.glUseProgram(mProgramId);
  27.     }
  29.     @Override
  30.     public void onSurfaceChanged(GL10 gl, int width, int height) {
  31.         //设置视图窗口
  32.         GLES30.glViewport(0, 0, width, height);
  33.         mModel.onModelChange(width, height);
  34.     }
  36.     @Override
  37.     public void onDrawFrame(GL10 gl) {
  38.         //将颜色缓冲区设置为预设的颜色
  39.         GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT);
  40.         //启用顶点的数组句柄
  41.         GLES30.glEnableVertexAttribArray(0);
  42.         GLES30.glEnableVertexAttribArray(1);
  43.         //绘制模型
  44.         mModel.onModelDraw();
  45.         //禁止顶点数组句柄
  46.         GLES30.glDisableVertexAttribArray(0);
  47.         GLES30.glDisableVertexAttribArray(1);
  48.     }
  49. }

​ Model.java

  1. package com.zhyan8.squaretocircle.model;
  3. import android.content.res.Resources;
  4. import android.graphics.Point;
  5. import android.opengl.GLES30;
  6. import com.zhyan8.squaretocircle.R;
  7. import com.zhyan8.squaretocircle.utils.ArraysUtils;
  8. import com.zhyan8.squaretocircle.utils.ShaderUtils;
  9. import com.zhyan8.squaretocircle.utils.TextureUtils;
  10. import java.nio.FloatBuffer;
  12. public class Model {
  13.     private static final int ROW_NUM = 60; // 纹理行数
  14.     private static final int COL_NUM = 60; // 纹理列数
  15.     private static final float ROW_WIDTH = 1.0f / ROW_NUM; // 每行宽度
  16.     private static final float COL_WIDTH = 1.0f / COL_NUM; // 每列宽度
  17.     private static final float SCALE = 1.0f; // 模型缩放系数
  18.     private static final int TEXTURE_DIMENSION = 2; // 纹理坐标维度
  19.     private static final int VERTEX_DIMENSION = 3; // 顶点坐标维度
  20.     private static final double EPSILON = 0.00000000001; // epsilon，比较小的浮点常量
  21.     private MyTransform mTransform = new MyTransform();
  22.     private float[][] mTextures;
  23.     private float[][] mVertices;
  24.     private FloatBuffer[] mTexturesBuffers;
  25.     private FloatBuffer[] mVerticesBuffers;
  26.     private int mTextureId;
  27.     private int mProgramId;
  28.     private int mPointNumPerRow;
  30.     public Model() {
  31.         mPointNumPerRow = (COL_NUM + 1) * 2;
  32.         mTextures = new float[ROW_NUM][mPointNumPerRow * TEXTURE_DIMENSION];
  33.         mVertices = new float[ROW_NUM][mPointNumPerRow * VERTEX_DIMENSION];
  34.         mTexturesBuffers = new FloatBuffer[ROW_NUM];
  35.         mVerticesBuffers = new FloatBuffer[ROW_NUM];
  36.     }
  38.     // 模型创建
  39.     public int onModelCreate(Resources resources) {
  40.         getTexture();
  41.         getVertex();
  42.         for (int i = 0; i < ROW_NUM; i++) {
  43.             mTexturesBuffers[i] = ArraysUtils.getFloatBuffer(mTextures[i]);
  44.             mVerticesBuffers[i] = ArraysUtils.getFloatBuffer(mVertices[i]);
  45.         }
  46.         mProgramId = ShaderUtils.createProgram(resources, R.raw.vertex_shader, R.raw.fragment_shader);
  47.         Point bitmapSize = new Point();
  48.         mTextureId = TextureUtils.loadTexture(resources, R.raw.zzz, bitmapSize);
  49.         mTransform.onTransformCreate(mProgramId, bitmapSize);
  50.         return mProgramId;
  51.     }
  53.     // 模型参数变化
  54.     public void onModelChange(int width, int height) {
  55.         mTransform.onTransformChange(width, height);
  56.     }
  58.     // 模型绘制
  59.     public void onModelDraw() {
  60.         mTransform.onTransformExecute();
  61.         for (int i = 0; i < ROW_NUM; i++) { // 一行一行绘制纹理
  62.             //准备顶点坐标和纹理坐标
  63.             GLES30.glVertexAttribPointer(0, VERTEX_DIMENSION, GLES30.GL_FLOAT, false, 0, mVerticesBuffers[i]);
  64.             GLES30.glVertexAttribPointer(1, TEXTURE_DIMENSION, GLES30.GL_FLOAT, false, 0, mTexturesBuffers[i]);
  65.             //激活纹理
  66.             GLES30.glActiveTexture(GLES30.GL_TEXTURE);
  67.             //绑定纹理
  68.             GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, mTextureId);
  69.             //绘制贴图
  70.             GLES30.glDrawArrays(GLES30.GL_TRIANGLE_STRIP, 0, mPointNumPerRow);
  71. //            GLES30.glDrawArrays(GLES30.GL_LINE_STRIP, 0, mPointNumPerRow);
  72.         }
  73.     }
  75.     // 计算纹理坐标
  76.     private void getTexture() {
  77.         for (int i = 0; i < ROW_NUM; i++) {
  78.             int index = 0;
  79.             float y1 = i * ROW_WIDTH;
  80.             float y2 = y1 + ROW_WIDTH;
  81.             float x = 0;
  82.             for (int j = 0; j <= COL_NUM; j++) {
  83.                 mTextures[i][index++] = x;
  84.                 mTextures[i][index++] = y1;
  85.                 mTextures[i][index++] = x;
  86.                 mTextures[i][index++] = y2;
  87.                 x += COL_WIDTH;
  88.             }
  89.         }
  90.     }
  92.     // 计算顶点坐标
  93.     private void getVertex() {
  94.         for (int i = 0; i < ROW_NUM; i++) {
  95.             int index = 0;
  96.             for (int j = 0; j < mTextures[i].length; j += TEXTURE_DIMENSION) {
  97.                 float[] pos = getPosInWorldAxis(mTextures[i][j], mTextures[i][j + 1]);
  98.                 textureVertexMapping(pos);
  99.                 mVertices[i][index++] = pos[0] * SCALE;
  100.                 mVertices[i][index++] = pos[1] * SCALE;
  101.                 mVertices[i][index++] = pos[2] * SCALE;
  102.             }
  103.         }
  104.     }
  106.     // 纹理坐标映射到顶点坐标
  107.     private void textureVertexMapping(float[] pos) {
  108.         float x = Math.abs(pos[0]);
  109.         float y = Math.abs(pos[1]);
  110.         double norm = Math.sqrt(x * x + y * y);
  111.         if (norm < EPSILON) {
  112.             return;
  113.         }
  114.         double normX = pos[0] / norm; // 归一化坐标
  115.         double normY = pos[1] / norm; // 归一化坐标
  116.         double rate = x > y ? y / x : x / y; // 短边与长边的比率
  117.         double dist = Math.sqrt(1 + rate * rate); // 圆心到正方形边上的距离
  118.         double factor = norm / dist; // 相对位置缩放因子
  119. //        double adjustNorm = adjustDist(norm);
  120. //        double adjustDist = adjustDist(dist);
  121. //        double factor = adjustNorm / adjustDist; // 相对位置缩放因子
  122.         pos[0] = (float) (normX * fun(factor));
  123.         pos[1] = (float) (normY * fun(factor));
  124.     }
  126.     // 调整距离
  127.     private double adjustDist(double dist) {
  128.         if (dist < 1) return dist;
  129.         double rest = dist - 1;
  130.         double more = rest / 2;
  131.         return 1 + more;
  132.     }
  134.     // 因子变换函数
  135.     private double fun(double x) {
  136.         return x;
  137. //        return Math.sqrt(x);
  138. //        return Math.pow(x, 0.3);
  139. //        return Math.log(x + 1) / Math.log(2);
  140. //        return Math.log10(x + 1) / Math.log10(2);
  141. //        return Math.sin(Math.PI / 2 * x);
  142.     }
  144.     //纹理坐标转换为世界坐标
  145.     private float[] getPosInWorldAxis(float x, float y) {
  146.         float [] pos = new float[VERTEX_DIMENSION];
  147.         pos[0] = x * 2 - 1;
  148.         pos[1] = 1 - y * 2;
  149.         pos[2] = 0f;
  150.         return pos;
  151.     }
  152. }

​ MyTransform.java

  1. package com.zhyan8.squaretocircle.model;
  3. import android.graphics.Point;
  4. import android.opengl.GLES30;
  5. import android.opengl.Matrix;
  7. public class MyTransform {
  8.     private int mProgramId;
  9.     private Point mBitmapSize;
  10.     private Point mViewSize;
  11.     private int mMvpMatrixHandle;
  12.     private float[] mMvpMatrix = new float[16];
  14.     public void onTransformCreate(int programId, Point bitmapSize) {
  15.         mProgramId = programId;
  16.         mBitmapSize = bitmapSize;
  17.         mMvpMatrixHandle = GLES30.glGetUniformLocation(mProgramId, "mvpMatrix");
  18.     }
  20.     public void onTransformChange(int width, int height) {
  21.         mViewSize = new Point(width, height);
  22.     }
  24.     //调整图片宽高适配屏幕尺寸
  25.     public void onTransformExecute() {
  26.         int mapWidth = mBitmapSize.x;
  27.         int mapHeight = mBitmapSize.y;
  28.         float mapRatio = mapWidth / (float) mapHeight;
  29.         float ratio = mViewSize.x / (float) mViewSize.y;
  30.         float w = 1.0f;
  31.         float h = 1.0f;
  32.         if (mapRatio > ratio) { //宽度最大，高度适配
  33.             h = mapRatio / ratio;
  34.         } else { //高度最大，宽度适配
  35.             w = ratio / mapRatio;
  36.         }
  37.         Matrix.orthoM(mMvpMatrix, 0, -w, w, -h, h,-1, 1);
  38.         GLES30.glUniformMatrix4fv(mMvpMatrixHandle, 1, false, mMvpMatrix, 0);
  39.     }
  40. }

​ ShaderUtils.java

  1. package com.zhyan8.squaretocircle.utils;
  3. import android.content.res.Resources;
  4. import android.opengl.GLES30;
  5. import java.io.BufferedReader;
  6. import java.io.InputStream;
  7. import java.io.InputStreamReader;
  9. public class ShaderUtils {
  10.     //创建程序id
  11.     public static int createProgram(Resources resources, int vertexShaderResId, int fragmentShaderResId) {
  12.         final int vertexShaderId = compileShader(resources, GLES30.GL_VERTEX_SHADER, vertexShaderResId);
  13.         final int fragmentShaderId = compileShader(resources, GLES30.GL_FRAGMENT_SHADER, fragmentShaderResId);
  14.         return linkProgram(vertexShaderId, fragmentShaderId);
  15.     }
  17.     //通过外部资源编译着色器
  18.     private static int compileShader(Resources resources, int type, int shaderId){
  19.         String shaderCode = readShaderFromResource(resources, shaderId);
  20.         return compileShader(type, shaderCode);
  21.     }
  23.     //通过代码片段编译着色器
  24.     private static int compileShader(int type, String shaderCode){
  25.         int shader = GLES30.glCreateShader(type);
  26.         GLES30.glShaderSource(shader, shaderCode);
  27.         GLES30.glCompileShader(shader);
  28.         return shader;
  29.     }
  31.     //链接到着色器
  32.     private static int linkProgram(int vertexShaderId, int fragmentShaderId) {
  33.         final int programId = GLES30.glCreateProgram();
  34.         //将顶点着色器加入到程序
  35.         GLES30.glAttachShader(programId, vertexShaderId);
  36.         //将片元着色器加入到程序
  37.         GLES30.glAttachShader(programId, fragmentShaderId);
  38.         //链接着色器程序
  39.         GLES30.glLinkProgram(programId);
  40.         return programId;
  41.     }
  43.     //从shader文件读出字符串
  44.     private static String readShaderFromResource(Resources resources, int shaderId) {
  45.         InputStream is = resources.openRawResource(shaderId);
  46.         BufferedReader br = new BufferedReader(new InputStreamReader(is));
  47.         String line;
  48.         StringBuilder sb = new StringBuilder();
  49.         try {
  50.             while ((line = br.readLine()) != null) {
  51.                 sb.append(line);
  52.                 sb.append("\n");
  53.             }
  54.             br.close();
  55.         } catch (Exception e) {
  56.             e.printStackTrace();
  57.         }
  58.         return sb.toString();
  59.     }
  60. }

​ TextureUtils.java

  1. package com.zhyan8.squaretocircle.utils;
  3. import android.content.res.Resources;
  4. import android.graphics.Bitmap;
  5. import android.graphics.BitmapFactory;
  6. import android.graphics.Point;
  7. import android.opengl.GLES30;
  8. import android.opengl.GLUtils;
  10. public class TextureUtils {
  11.     //加载纹理贴图
  12.     public static int loadTexture(Resources resources, int resourceId, Point bitmapSize) {
  13.         BitmapFactory.Options options = new BitmapFactory.Options();
  14.         options.inScaled = false;
  15.         Bitmap bitmap = BitmapFactory.decodeResource(resources, resourceId, options);
  16.         bitmapSize.set(bitmap.getWidth(), bitmap.getHeight());
  17.         final int[] textureIds = new int[1];
  18.         // 生成纹理id
  19.         GLES30.glGenTextures(1, textureIds, 0);
  20.         // 绑定纹理到OpenGL
  21.         GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, textureIds[0]);
  22.         GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MIN_FILTER, GLES30.GL_LINEAR_MIPMAP_LINEAR);
  23.         GLES30.glTexParameteri(GLES30.GL_TEXTURE_2D, GLES30.GL_TEXTURE_MAG_FILTER, GLES30.GL_LINEAR);
  24.         // 加载bitmap到纹理中
  25.         GLUtils.texImage2D(GLES30.GL_TEXTURE_2D, 0, bitmap, 0);
  26.         // 生成MIP贴图
  27.         GLES30.glGenerateMipmap(GLES30.GL_TEXTURE_2D);
  28.         // 取消绑定纹理
  29.         GLES30.glBindTexture(GLES30.GL_TEXTURE_2D, 0);
  30.         return textureIds[0];
  31.     }
  32. }

​ ArraysUtils.java

  1. package com.zhyan8.squaretocircle.utils;
  3. import java.nio.ByteBuffer;
  4. import java.nio.ByteOrder;
  5. import java.nio.FloatBuffer;
  7. public class ArraysUtils {
  8.     public static FloatBuffer getFloatBuffer(float[] floatArr) {
  9.         FloatBuffer fb = ByteBuffer.allocateDirect(floatArr.length * Float.BYTES)
  10.             .order(ByteOrder.nativeOrder())
  11.             .asFloatBuffer();
  12.         fb.put(floatArr);
  13.         fb.position(0);
  14.         return fb;
  15.     }
  16. }

​ vertex_shader.glsl

  1. #version 300 es
  2. layout (location = 0) in vec4 vPosition;
  3. layout (location = 1) in vec2 aTextureCoord;
  4. uniform mat4 mvpMatrix;
  5. out vec2 vTexCoord;
  6. void main() {
  7.      gl_Position  = mvpMatrix * vPosition;
  8.      vTexCoord = aTextureCoord;
  9. }

​ 顶点着色器的作用：进行矩阵变换位置、根据光照公式计算顶点颜⾊、⽣成 / 变换纹理坐标，并且把位置和纹理坐标发送到片元着色器。

​ 顶点着色器中，如果没有指定默认精度，则 int 和 float 的默认精度都为 highp。

​ fragment_shader.glsl

  1. #version 300 es
  2. precision mediump float;
  3. uniform sampler2D uTextureUnit;
  4. in vec2 vTexCoord;
  5. out vec4 fragColor;
  6. void main() {
  7.      fragColor = texture(uTextureUnit,vTexCoord);
  8. }

​ 片元着色器的作用：处理经光栅化阶段生成的每个片元，计算每个像素的颜色和透明度。

​ 在片元着色器中，浮点值没有默认的精度值，每个着色器必须声明一个默认的 float 精度。

3 运行效果

​ 1）因子变换函数：y=x

​

​ 2）因子变换函数：y=sqrt(x)

​

​ 3）因子变换函数：y=log10(1+x)/log10(2)

​

​ 4）因子变换函数：y=sin(πx/2)

​

​ 5）因子变换函数：y=x，对距离进行调整

​ 鉴于以上图片头发都鼓起一个大包，对距离进行调整，如下：

  1. double adjustNorm = adjustDist(norm);
  2. double adjustDist = adjustDist(dist);
  3. double factor = adjustNorm / adjustDist; // 相对位置缩放因子
  5. // 调整距离
  6. private double adjustDist(double dist) {
  7.     if (dist < 1) return dist;
  8.     double rest = dist - 1;
  9.     double more = rest / 2;
  10.     return 1 + more;
  11. }

​ 效果如下：

​

​ 虽然头发也有个小包，但比前面4种方案小了很多。

​ 声明：本文转自【OpenGL ES】正方形图片贴到圆形上

【OpenGL ES】正方形图片贴到圆形上的更多相关文章

  1. OpenGL ES: (2) OpenGL ES 与 EGL、GLSL的关系

    OpenGL ES 是负责 GPU 工作的,目的是通过 GPU 计算,得到一张图片,这张图片在内存中其实就是一块 buffer,存储有每个点的颜色信息等.而这张图片最终是要显示到屏幕上,所以还需要具体 ...

  2. OpenGL ES: (5) OpenGL的基本概念、OpenGL ES 在屏幕产生图片的过程、OpenGL管线(pipeline)

    一. OpenGL的基本概念 OpenGL 的结构可以从逻辑上划分为下面 3 个部分: 图元(Primitives) 缓冲区(Buffers) 光栅化(Rasterize) 图元(Primitives ...

  3. Android OpenGL ES 开发（九）: OpenGL ES 纹理贴图

    一.概念 一般说来,纹理是表示物体表面的一幅或几幅二维图形,也称纹理贴图(texture).当把纹理按照特定的方式映射到物体表面上的时候,能使物体看上去更加真实.当前流行的图形系统中,纹理绘制已经成为 ...

  4. 一篇通俗易懂的讲解OpenGL ES的文章

    电脑或者手机上做图像处理有很多方式,但是目前为止最高效的方法是有效地使用图形处理单元,或者叫 GPU.你的手机包含两个不同的处理单元,CPU 和 GPU.CPU 是个多面手,并且不得不处理所有的事情, ...

  5. OpenGL ES学习笔记（三）——纹理

    首先申明下,本文为笔者学习<OpenGL ES应用开发实践指南(Android卷)>的笔记,涉及的代码均出自原书,如有需要,请到原书指定源码地址下载. <OpenGL ES学习笔记( ...

  6. OpenGL ES 3.0 图元装配

    1. 前言 之前已经把纹理的渲染给弄出来了,但是又遇到一个新的问题,那就是图元装配,比如说我已经把图片给显示出来了,但是呢,并没有做到让它显示到具体的位置,而跟这个位置相关的则需要靠图元装配. 图元装 ...

  7. Opengl ES 1.x NDK实例开发之六:纹理贴图

    开发框架介绍请參见:Opengl ES NDK实例开发之中的一个:搭建开发框架 本章在第三章(Opengl ES 1.x NDK实例开发之三:多边形的旋转)的基础上演示怎样使用纹理贴图,分别实现了三角 ...

  8. Android OpenGL ES 画球体

    近期由于兴趣所向.開始学习OpenGL绘图. 本文以"画球体"为点,小结一下近期所学. > 初识OpenGL ES 接触OpenGL是从Android開始的.众所周知,And ...

  9. Android OpenGL ES(七)----理解纹理与纹理过滤

    1.理解纹理 OpenGL中的纹理能够用来表示图像.照片,甚至由一个数学算法生成的分形数据.每一个二维的纹理都由很多小的纹理元素组成.它们是小块的数据,类似于我们前面讨论过的片段和像素.要使用纹理,最 ...

  10. Opengl ES之纹理贴图

    纹理可以理解为一个二维数组,它可以存储大量的数据,这些数据可以发送到着色器上.一般情况下我们所说的纹理是表示一副2D图,此时纹理存储的数据就是这个图的像素数据. 所谓的纹理贴图,就是使用Opengl将 ...

随机推荐

  1. 调整PR界面字体大小

    1.问题 界面字体太大或者太小,看得不舒服 2.解决问题 按住ctrl+F12,调出如下工作台 选择Debug Datatbase View 其中找到AdobeCleanFontSize,并修改 重启 ...

  2. html监听标签的resize

    <html> <body> <div id="div1" style="width:100%;height:100%;"> ...

  3. Pickle反序列化学习

    什么是Pickle? 很简单,就是一个python的序列化模块,方便对象的传输与存储.但是pickle的灵活度很高,可以通过对opcode的编写来实现代码执行的效果,由此引发一系列的安全问题 Pick ...

  4. SkyWalking的学习之三

    SkyWalking的学习之三 持续优化 SkyWalking 默认可以使用h2,但是感觉容量和性能都可能不太好 所以我想使用一下elasticSearch进行替换. 自己其实一直想心想去学习, 但是 ...

  5. SQLServer解决deadlock问题的一个场景

    SQLServer解决deadlock问题的一个场景 背景 公司产品出现过很多次dead lock 跟研发讨论了很久, 都没有具体的解决思路 但是这边知道了一个SQLServer数据库上面计划100% ...

  6. [转帖]perf学习-linux自带性能分析工具

    目前在做性能分析的事情,之前没怎么接触perf,找了几篇文章梳理了一下,按照问题的形式记录在这里. 方便自己查看.   什么是perf? linux性能调优工具,32内核以上自带的工具,软件性能分析. ...

  7. [转帖]Tiup 常用运维操作命令干货

    https://zhuanlan.zhihu.com/p/356031031 **导读**> 作者:杨漆> 16年关系型数据库管理,从oracle 9i .10g.11g.12c到Mysq ...

  8. 【转帖】SmartNIC — TSO、GSO、LRO、GRO 技术

    目录 文章目录 目录 TSO(TCP Segmentation Offload) GSO(Generic Segmentation Offload) LRO(Large Receive Offload ...

  9. 是否开启raid卡缓存的影响

    开启raid卡缓存 Write back 对IO性能的影响 背景 公司买了一台服务器. 想进行一下升级 但是因为管理员担心数据丢失, 使用了write through + (raid6 + hotsp ...

  10. SpringBoot 连接Oracle 12c 以上版本PDB的解决思路

    1. 最近公司产品改用springboot开发, 要支持企业级大型数据库Oracle ,并且版本要求比较高,需要使用Oracle12c以上. 又因为Oracle 12c 以上有了一个PDB的可插拔数据 ...