线程以及缓冲区

[size=medium]1.线程
  我们把正在计算机中执行的程序叫做"进程"。所谓"线程",是"进程"中某个单一顺序的控制流。在单个程序中同时运行多个线程完成不同的工作,称为多线程。通俗的说法,之前编的程序如果一个指令没进行完,则不能进行下一个指令,或者不能关闭窗口。利用多线程,可以完成多个指令的同时运行。
需要继承Thread[/size]
public class Hua extends Thread{
private Graphics g;
private JFrame jf;
private int j=0;
public Hua(JFrame jf,Graphics g){
this.g=jf.getGraphics();
this.jf=jf;
}
//运行的方法
public void run(){
draw(g);
}
//画小孩的方法
public void draw(Graphics g2){
int juli=160;
g2.setColor(Color.black);
if(j<juli)
j++;
if(j==juli)
j=juli;
g.fillOval(60+j, 460, 40,40);//头
g.drawLine(80+j, 500, 70+j, 520);
g.drawLine(80+j, 500,90+j, 520);
g.drawLine(80+j, 500, 80+j, 540);//竖
if(60+j+j<100+j)
g2.drawLine(80+j, 540, 60+j+j, 560);//腿1
if((60+j+j>=100+j)&&(60+j+j<=100+40+j)){
g2.drawLine(80+j, 540,140, 560);//腿1
}
if((100+80+j>60+j+j)&&(60+j+j>100+40+j))
g2.drawLine(80+j, 540, 100+j+j-120, 560);//腿1
if(100+80+j<60+j+j)
g2.drawLine(80+j, 540, 220, 560);//腿1
/************腿2****************/
if(100>=60+j)
g2.drawLine(80+j, 540,100, 560);
if((100<60+j)&&(60+j+j-40<100+j))
g2.drawLine(80+j,540,60+j+j-40,560);//腿2
if((60+j+j-40<=140+j)&&(60+j+j-40>=100+j)){
g2.drawLine(80+j, 540,180, 560);//腿2
}
if(60+j+j-40>140+j){
g2.drawLine(80+j, 540,60+j+j-120, 560);//腿2
}

try {
Thread.sleep(40);
} catch (InterruptedException e1) {
e1.printStackTrace();
}

}
}

[size=medium]在调用Hua的页面中实例化Hua类,并开始运行[/size]
 Hua hua=new Hua(this,gg);
hua.start();

[size=medium]可多个同时运行
2.缓冲区
在制作动画的时候发现背景总是闪,因为 先用背景色覆盖整个组件,然后再调用paint(Graphics g)函数,重新绘制图形。这样,我们每次看到的都是一个在新的位置绘制的图形,前面的图形都被背景色覆盖掉了。这就像一帧一帧的画面匀速地切换,以此来实现动画的效果。 但是,正是这种先用背景色覆盖组件再重绘图像的方式导致了闪烁。如果先把背景和图像画好,再画在界面上,效果会好些。
新组件:BufferedImage[/size]
 while(true){
//在内存中创建一个缓冲画图对象
BufferedImage buffer=new BufferedImage(this.getWidth(),this.getHeight(),BufferedImage.TYPE_INT_BGR);

//得到缓冲图对象的画布
Graphics g=buffer.getGraphics();
this.getHeight());
//画背景,把背景画在缓冲图上
g.drawImage(image.getImage(), x, 0, null);
g.drawImage(image.getImage(), x+image.getIconWidth(), 0, null);
x-=2;
if(x+image.getIconWidth() <=0 ){
x=0;
}
hua.draw(g);
//画好之后显示缓冲图上的图片
gg.drawImage(buffer, 0, 0, null);
}
  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
环形缓冲区(Circular Buffer)是一种常见的数据结构,也称为循环缓冲区或环形队列。它具有固定大小的缓冲区,可以循环使用,实现高效的读写操作。 单线程环形缓冲区(Single-Threaded Circular Buffer)是指在单线程环境下使用的环形缓冲区。它适用于单线程程序,其中只有一个线程负责读取和写入缓冲区。 单线程环形缓冲区的实现可以借助数组来存储数据,并使用两个指针来标记读取和写入位置。以下是一个简单的示例代码(使用C语言): ```c #define BUFFER_SIZE 10 typedef struct { int buffer[BUFFER_SIZE]; int read_index; int write_index; } CircularBuffer; void init_buffer(CircularBuffer* buf) { buf->read_index = 0; buf->write_index = 0; } void write_buffer(CircularBuffer* buf, int data) { buf->buffer[buf->write_index] = data; buf->write_index = (buf->write_index + 1) % BUFFER_SIZE; } int read_buffer(CircularBuffer* buf) { int data = buf->buffer[buf->read_index]; buf->read_index = (buf->read_index + 1) % BUFFER_SIZE; return data; } ``` 在上述代码中,`BUFFER_SIZE` 定义了缓冲区的大小。`CircularBuffer` 结构体包含一个整型数组 `buffer` 用于存储数据,以及两个指针 `read_index` 和 `write_index` 分别表示读取和写入的位置。 通过 `init_buffer` 函数来初始化缓冲区。`write_buffer` 函数用于向缓冲区写入数据,将数据存储在 `write_index` 指向的位置,并更新 `write_index` 的值。`read_buffer` 函数用于从缓冲区读取数据,获取 `read_index` 指向的位置的数据,并更新 `read_index` 的值。 需要注意的是,当写入或读取位置到达缓冲区的末尾时,指针需要循环回到缓冲区的起始位置,这是通过使用模运算来实现的:`(index + 1) % BUFFER_SIZE`。 这样,单线程环形缓冲区就可以实现循环使用,实现高效的读取和写入操作。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值