Go语言视频零基础入门到精通

javalearner

Applet是在浏览器中运行的小程序，java也是从Applet开始风靡世界的。通过编写这个Applet，我们可以学习到如下知识：

1、Applet及JApplet中的主要接口

2、图像的装载及MediaTracker的使用

3、线程的使用及多个线程直接的通讯

4、Thread.join()方法的使用

5、volatile关键字的使用

动画的主要部分是一个Applet，从codebase中读取一组图片文件，然后每隔1秒轮换显示一张。代码如下：
  
   
   
   

   
  

   



  
   
   
     
   

2.       
3.         import javax.swing.JApplet;
   
4. import java.awt.Graphics;
   
5. import java.awt.Image;
   
6. import java.awt.MediaTracker;
   
7. public class Animate extends JApplet
   
8. {
   
9.     //图片数量
   
10.     private static final int NUM_OF_PIC = 4;
    
11.      
    
12.     int count;
    
13.     Image pics[];
    
14.     TimerThread timer;
    
15.      
    
16.     public void init()
    
17.         {
    
18.         count = 1;
    
19.         pics = new Image[NUM_OF_PIC];
    
20.         MediaTracker tracker =
    
21.                 new MediaTracker(this);
    
22.         for(int i = 0; i<NUM_OF_PIC; i++)
    
23.                 {
    
24.     //将图片按照0,1,...,NUM_OF_PIC -1,
    
25.         放置在目录中，格式为.jpg
    
26.             pics[i] = getImage(getCodeBase(),
    
27.                 new Integer(i).toString()+".jpg");
    
28.             tracker.addImage(pics[i], 0);
    
29.         }
    
30.         tracker.checkAll(true);
    
31.          
    
32.     }
    
33.      
    
34.     public void start()
    
35.         {
    
36.             timer = new TimerThread(this, 1000);
    
37.             timer.start();
    
38.     }
    
39.      
    
40.     public void stop()
    
41.         {
    
42.         timer.shouldRun = false;
    
43.         try {
    
44.             timer.join();
    
45.                         //等待timer线程退出
    
46.         } catch (InterruptedException e)
    
47.                 {
    
48.                 };
    
49.     }
    
50.      
    
51.     public void paint(Graphics g)
    
52.         {
    
53.         g.drawImage(pics[count++], 0, 0, null);
    
54.         if(count == NUM_OF_PIC) count = 0;
    
55.     }
    
56.      
    
57. }
58.       

复制代码

     
   
   
  


动画的控制由一个专门的线程TimerThread进行处理。



  
   
   
     
   

2.       
3.         import java.awt.Component;
   
4. public class TimerThread extends Thread
   
5. {
   
6.     Component comp;
   
7.     int timediff;
   
8.      
   
9.     //    shouldRun声明为volatile
   
10.     volatile boolean shouldRun;
    
11.      
    
12.     public TimerThread
    
13.         (Component comp, int timediff)
    
14.         {
    
15.         super("TimerThread
    
16.                 (" + timediff + " millseconds");
    
17.         this.comp = comp;
    
18.         this.timediff = timediff;
    
19.         shouldRun = true;
    
20.     }
    
21.      
    
22.     public void run()
    
23.         {
    
24.         while(shouldRun)
    
25.                 {
    
26.             try
    
27.                         {
    
28.                 comp.repaint();
    
29.                 sleep(timediff);
    
30.             } catch (Exception e)
    
31.                         {
    
32.                         }
    
33.         }
    
34.     }
    
35. }
36.       

复制代码

     
   
   
  


MediaTracker的使用

在Applet中获取一个图像文件，可以调用Applet的getImage()方法。但是getImage方法会在调用后马上返回，如果此时马上使用getImage获取的Image对象，而这时Image对象并没有真正装载或者装载完成。

所以，我们在使用图像文件时，使用java.awt包中的MediaTracker跟踪一个Image对象的装载，可以保证所有图片都加载完毕。使用MediaTracker需要如下三个步骤：

1、实例化一个MediaTracker，注意要将显示图片的Component对象作为参数传入。



  
   
   
     
   

2.       
3.         MediaTracker tracker = new MediaTracker(this);
4.       

复制代码

     
   
   
  


2、将要装载的Image对象加入MediaTracker



  
   
   
     
   

2.       
3.         pics[i] = getImage(getCodeBase(),
   
4.   new Integer(i).toString()+".jpg");
   
5. tracker.addImage(pics[i], 0);
6.       

复制代码

     
   
   
  


3、调用MediaTracker的checkAll()方法，等待装载过程的结束。



  
   
   
     
   

2.       
3.         tracker.checkAll(true);
4.       

复制代码

     
   
   
  


Thread.join()的使用

我们在Animate的stop方法中调用timer的join()方法，将timer线程连接（join）到当前线程，当前线程会一致会等待timer线程运行结束后，timer.join()方法才会返回。

如果当前线程在等待timer返回的过程中，被其它线程中断了，那么当前线程会抛出InterruptedException。如果不使用Thread的join方法，那么只能通过轮询timer线程的状态进行判断了：



  
   
   
     
   

2.       
3.         while (timer.isAlive())
   
4. {
   
5.       try
   
6.           {
   
7.         Thread.sleep(50);
   
8.            }
   
9.                    catch (InterruptedException e)
   
10.                    {
    
11.                    }
    
12.          }
13.       

复制代码

     
   
   
  


显然这种办法和使用join方法相比，会浪费cpu资源，同时也会浪费一些等待时间，因为当前线程每隔一段时间去查询timer线程是否还存活，可能在timer线程已经结束了，但是当前线程还是要等待一段时间才能去监测它。

关于volatile

我们知道，在Java中设置变量值的操作，除了long和double类型的变量外都是原子操作，也就是说，对于变量值的简单读写操作没有必要进行同步。这在JVM 1.2之前，Java的内存模型实现总是从主存读取变量，是不需要进行特别的注意的。

而随着JVM的成熟和优化，现在在多线程环境下volatile关键字的使用变得非常重要。在当前的Java内存模型下，线程可以把变量保存在本地内存（比如机器的寄存器）中，而不是直接在主存中进行读写。

这就可能造成一个线程在主存中修改了一个变量的值，而另外一个线程还继续使用它在寄存器中的变量值的拷贝，造成数据的不一致。

要解决这个问题，只需要像在本程序中的这样，把该变量声明为volatile（不稳定的）即可，这就指示JVM，这个变量是不稳定的，每次使用它都到主存中进行读取。一般说来，多任务环境下各任务间共享的标志都应该加volatile修饰。
  

  
  
   
   

     
   

     
   
  


  



                        function TempSave(ElementID)
                        {
                                CommentsPersistDiv.setAttribute("CommentContent",document.getElementById(ElementID).value);
                                CommentsPersistDiv.save("CommentXMLStore");
                        }
                        function Restore(ElementID)
                        {
                                CommentsPersistDiv.load("CommentXMLStore");
                                document.getElementById(ElementID).value=CommentsPersistDiv.getAttribute("CommentContent");
                        }
               
                  











源码下载：http://file.javaxxz.com/2014/10/1/075429422.zip