Junit是由 Erich Gamma 和 Kent Beck 編寫的一個回歸測試框架（regression testing framework）。Junit是一套框架，繼承TestCase類，就可以用Junit進行自動測試了。

 

1 junit特性

　　

  

junit

Junit是一個開放源代碼的Java測試框架，用于編寫和運行可重復的測試。他是用于單元測試框架體系xUnit的一個實例（用于java語言）。它包括以下特性：

　　① 用于測試期望結果的斷言（Assertion）

　　② 用于共享共同測試數據的測試工具

　　③ 用于方便的組織和運行測試的測試套件

④ 圖形和文本的測試運行器

 
2 Eclipse中配置Junit

右擊要使用的junit的項目，點擊properties—java bulid path-libraries，點擊Add External JARs,加上JUNIT包。

 

 3 用法

- 創建，從junit.framework.TestCase派生nuit test需要的test case.

- 書寫測試方法

- 編譯 書寫玩test case后，編譯所寫的test case類

- 運行，啟動junit test runnner 來運行這個test case。

 

 

實例代碼：

package com.dr.test;

 

import java.util.List;

 

import junit.framework.TestCase;

import com.dr.dao.StudentDao;

import com.dr.dao.impl.StudentDaoImpl;

import com.dr.vo.Student;

 

public class StudentDaoImplTest extends TestCase{

   

    StudentDao dao;

   

    protected void setUp() throws Exception{

       dao=new StudentDaoImpl();

      

    }

    protected void tearDown() throws Exception{

      

    }

    public void testAdd(){

       Student stu=new Student();

       stu.setName("ling");

       stu.setAge(1);

       stu.setEmail("ling@126.com");

       dao.addStudent(stu);

    }

    public void testListStudent(){

       List<Student> list=dao.getStudentList();

       System.out.println(list.size());

    }

   

}

 

Junit中的兩個函數：setUp與tearDown,是junit framework中提供初始化金額反初始化每個測試方法的。setUp在每個測試方法調用前被調用，負責初始化測試方法所需要的測試環境；teardown在每個測試方法被調用之后被調用，負責撤銷測試環境。

 

測試結果：

 

在JUnit的窗口中顯示了一個綠條，綠條證明測試成功。

 

 

Listener是Servlet的監聽器，它可以監聽客戶端的請求、服務端的操作等。通過監聽器，可以自動激發一些操作，比如監聽在線的用戶的數量。當增加一個HttpSession時，就激發sessionCreated(HttpSessionEvent se)方法，這樣就可以給在線人數加1。常用的監聽接口有以下幾個：

ServletContextListener監聽ServletContext。當創建ServletContext時，激發 contextInitialized(ServletContextEvent sce)方法；當銷毀ServletContext時，激發contextDestroyed(ServletContextEvent sce)方法。

ServletContextAttributeListener監聽對ServletContext屬性的操作，比如增加、刪除、修改屬性。

HttpSessionListener監聽HttpSession的操作。當創建一個Session時，激發session Created(HttpSessionEvent se)方法；當銷毀一個Session時，激發sessionDestroyed (HttpSessionEvent se)方法。

HttpSessionAttributeListener監聽HttpSession中的屬性的操作。當在Session增加一個屬性時，激發 attributeAdded(HttpSessionBindingEvent se) 方法；當在Session刪除一個屬性時，激發attributeRemoved(HttpSessionBindingEvent se)方法；當在Session屬性被重新設置時，激發attributeReplaced(HttpSessionBindingEvent se) 方法。

下面我們開發一個具體的例子，這個監聽器能夠統計在線的人數。

程序源代碼：

package com.dr.web.listener;

import javax.servlet.ServletContext;

import javax.servlet.ServletContextEvent;

import javax.servlet.ServletContextListener;

import javax.servlet.http.HttpSessionEvent;

import javax.servlet.http.HttpSessionListener;

publicclass UserCountListener implements ServletContextListener,

       HttpSessionListener {

    //每個web應用都有且僅有一個ServletContext對象，這個對象在所有的Servlet都可以使用。

    /**

     * 因為一個web應用就一個ServletContext 對象，因此可以使用ServletContext 來做一些全局性的屬性設置等。

     * 比如網站訪問計數器等等

     *

     *

     * ServletContext 是一個應用程序與Web容器(tomcat之類)交互的接口,同時它也是管理應用程序資源的對象，

                                                   通過它可以讀取web.xml中一些配置，如<context-param>中的信息，讀取應用中的資源等。

       Session 是一個會話對象，也就是說當客戶端訪問服務器頁面時，它才產生，

                                        原理是服務器對每個客戶端產生一個sessionid值,并把它也保存在客戶端，

                                        每次請求時驗證這個sessionid是否是創建了sessionid的客戶端，在服務器端對應這個sessionid會創建一個緩存區，

                                        存儲一些相關信息,程序員可以操作，如被用于購物車，存儲用戶信息等，這個區域只有對特定用戶有訪問權限，對其他客戶是拒絕訪問的，這就是一個會話。

       Request 是一個請求對象，也就是說它的生命很短暫，只在一個請求中存在，如一個頁面到另一個頁面，

                                     一個頁面到servlet或action,一個servlet或action到jsp頁面等,你可以用它的setAttribute方法傳遞需要的信息(對象),驗證請求方的信息,獲得請求方發過來的文件內容等。

     */

    private ServletContext sc;

    publicvoid contextDestroyed(ServletContextEvent arg0) {

   

    }

    publicvoid contextInitialized(ServletContextEvent event) {

      

       ServletContext sc = event.getServletContext();

       sc.setAttribute("Users", new Integer(0));

       this.sc = sc;

    }

    publicvoid sessionCreated(HttpSessionEvent event) {//在線

       System.out.println("new user login our web site");

       Integer users = (Integer)sc.getAttribute("Users");

       sc.setAttribute("Users", ++users);

    }

    publicvoid sessionDestroyed(HttpSessionEvent event) {

       Integer users = (Integer)sc.getAttribute("Users");

       sc.setAttribute("Users", --users);

    }

}

Web.xml中配置如下：

    <listener>

       <listener-class>com.dr.web.listener.UserCountListener</listener-class>

    </listener>

在UserCountListener里，用users代表當前在線的人數，UserCountListener將在Web服務器啟動時自動執行。當UserCountListener構造好后，把users設置為 0。每增加一個Session，UserCountListener會自動調用sessionCreated(HttpSessionEvent event)方法；每銷毀一個Session，UserCountListener會自動調用 sessionDestroyed(HttpSessionEvent se)方法。當調用sessionCreated(HttpSessionEvent event)方法時，說明又有一個客戶在請求，此時使在線的人數（users）加1，并且把user寫到ServletContext中。 ServletContext的信息是所有客戶端共享的，這樣，每個客戶端都可以讀取到當前在線的人數。

運行結果：

     摘要:   MVC是三個單詞的縮寫,分別為： 模型(Model),視圖(View)和控制Control)。 MVC模式的目的就是實現Web系統的職能分工。 Model層實現系統中的業務邏輯，通常可以用JavaBean或EJB來實現。 View層用于與用戶的交互，通常用JSP來實現。 Control層是Model與View之間溝通的橋梁，它可以分派用戶的請求并選擇恰當的視圖以用于顯示，同時它也可...  閱讀全文

 

有些網站需要登錄以后才能訪問網站內部資源，這就需要我們做一個過濾器，當用戶訪問網站內部資源時，要先經過過濾器，過濾器判斷是否有這個用戶，有則跳轉進入網站內部頁面，沒有則返回登錄頁面。

 

過濾器代碼：

package com.dr.course;

 

import java.io.IOException;

 

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpSession;

 

import com.dr.common.Global;

import com.dr.vo.User;

 

public class IsLoginFilter implements Filter {

 

       public void destroy() {

             

       }

 

       public void doFilter(ServletRequest request, ServletResponse response,

                     FilterChain filterChain) throws IOException, ServletException {

             

              System.out.println("every request pass here");

              HttpServletRequest hrequest=(HttpServletRequest)request;

              HttpSession session=hrequest.getSession();

              User user =     (User)session.getAttribute(Global.USER);

              if(user == null){

                     //跳轉到登陸頁面

            hrequest.getRequestDispatcher("/index.jsp").forward(request,response);                 

              }

              filterChain.doFilter(request, response);

       }

 

       public void init(FilterConfig filterConfig) throws ServletException {

             

       }

 

}

 

LoginServlet類，進行登錄之后的處理：

package com.dr.course;

 

import java.io.IOException;

 

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import javax.servlet.http.HttpSession;

 

import com.dr.common.Global;

import com.dr.vo.User;

 

public class LoginServlet extends HttpServlet{

      

       public void doPost(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{

             

              String userName=request.getParameter("username");

              String passWord=request.getParameter("password");

             

          

            System.out.println("userName | " + userName);

            System.out.println("passWord | " + passWord);

            User user = new User();

            user.setUserName(userName);

            user.setPassWord(passWord);

            HttpSession session = request.getSession();

            //登錄成功，把User放到session，然后在攔截器中判斷

            //key--value

            session.setAttribute(Global.USER, user);

            request.getRequestDispatcher("/admin/main.jsp").forward(request, response);

             

             

             

       }

 

}

 

web.xml中配置如下：

- <filter>

  <filter-name>isLogin</filter-name>

  <filter-class>com.dr.course.IsLoginFilter</filter-class>

  </filter>

- <filter-mapping>

  <filter-name>isLogin</filter-name>

  <url-pattern>/admin/*</url-pattern>

  </filter-mapping>

- <servlet>

  <servlet-name>login</servlet-name>

  <servlet-class>com.dr.course.LoginServlet</servlet-class>

  </servlet>

- <servlet-mapping>

  <servlet-name>login</servlet-name>

  <url-pattern>/login</url-pattern>

  </servlet-mapping>

 未登錄界面：

成功登錄的界面：

 

cookie為用戶登陸服務器后，服務器寫在客戶端的文件。

我們在登錄126郵箱時，如果勾選上兩周內自動登錄，兩周內不用輸入用戶名和密碼郵箱會自動登錄，這是因為第一次登錄時服務器將用戶名和密碼寫入cookie中，并返回給客戶端。

下次登錄時Http協議會帶著用戶的cookie去服務器驗證，因為服務器已經存儲用戶的信息，所以會自動登錄。

登錄代碼：

package com.dr.course;

import java.io.IOException;  

import javax.servlet.ServletException;  

import javax.servlet.http.Cookie;  

import javax.servlet.http.HttpServlet;  

import javax.servlet.http.HttpServletRequest;  

import javax.servlet.http.HttpServletResponse;  

public class LoginServlet extends HttpServlet {  

    public void doGet(HttpServletRequest request, HttpServletResponse response)  

            throws ServletException, IOException {  

        this.doPost(request, response);  

    }  

    public void doPost(HttpServletRequest request, HttpServletResponse response)  

            throws ServletException, IOException {  

           String username=request.getParameter("username");  

           String password=request.getParameter("password");  

           String savetime=request.getParameter("saveTime");  

           if(CheckLogin.login(username, password)){  

               if(null!=savetime){  

                   int saveTime=Integer.parseInt(savetime);//這里接受的表單值為天來計算的  

                   int seconds=saveTime*24*60*60;  

                   Cookie cookie = new Cookie("user", username+"=="+password);  

                   cookie.setMaxAge(seconds);                     

                   response.addCookie(cookie);  

               }  

               request.setAttribute("username",username);  

               request.getRequestDispatcher("/main126.jsp").forward(request,response);  

           }else{  

               request.getRequestDispatcher("/failure.jsp").forward(request,response);  

           }  

    }  

}  

驗證代碼：

package com.dr.course;

import java.io.IOException;  

import javax.servlet.Filter;  

import javax.servlet.FilterChain;  

import javax.servlet.FilterConfig;  

import javax.servlet.ServletException;  

import javax.servlet.ServletRequest;  

import javax.servlet.ServletResponse;  

import javax.servlet.http.Cookie;  

import javax.servlet.http.HttpServletRequest;  

import javax.servlet.http.HttpServletResponse;  

public class IndexFilter implements Filter {  

    public void destroy() {  

        // TODO Auto-generated method stub  

    }  

    public void doFilter(ServletRequest arg0, ServletResponse arg1,  

            FilterChain arg2) throws IOException, ServletException {

          

           System.out.println("every request pass here haha");

        HttpServletRequest request = (HttpServletRequest) arg0;  

        HttpServletResponse response = (HttpServletResponse) arg1;  

        Cookie[] cookies = request.getCookies();  

        String[] cooks = null;  

        String username = null;  

        String password = null;  

        if (cookies != null) {  

            for (Cookie coo : cookies) {  

                String aa = coo.getValue();  

                cooks = aa.split("==");  

                if (cooks.length == 2) {  

                    username = cooks[0];  

                    password = cooks[1];  

                }  

            }  

        }

        System.out.println("cookie username | " + username);

        System.out.println("cookie password | " + password);

        if (CheckLogin.login(username, password)) {

               System.err.println("check successfully cookie data ");

            request.getSession().setAttribute("username",username);  

            request.getRequestDispatcher("/main126.jsp").forward(request, response);

        }else{  

            arg2.doFilter(request,response );  

        }  

    }  

    public void init(FilterConfig arg0) throws ServletException {  

        // TODO Auto-generated method stub  

    }  

}

package com.dr.course;

public class CheckLogin {

        public static boolean login(String username, String password) {  

               if ("admin".equals(username) && "123456".equals(password)) {  

                   return true;  

               } else {  

                   return false;  

               }  

           }  

}

web.xml中配置如下：

- <filter>

 <filter-name>loginFilter</filter-name>

 <filter-class>com.dr.course.IndexFilter</filter-class>

 </filter>

- <filter-mapping>

 <filter-name>loginFilter</filter-name>

 <url-pattern>/main126.jsp</url-pattern>

 </filter-mapping>

- <servlet>

 <servlet-name>LoginServlet</servlet-name>

 <servlet-class>com.dr.course.LoginServlet</servlet-class>

 </servlet>

- <servlet-mapping>

 <servlet-name>LoginServlet</servlet-name>

 <url-pattern>/login.do</url-pattern>

 </servlet-mapping>

將目錄加入到Tomcat中，開啟Tomcat，打開瀏覽器輸入網址:http://127.0.0.1:8080/AutoLogin/login.do進行測試。

 

Http協議中默認的編碼字符集和平臺字符集都不是中文的，所以Web項目中經常會遇到中文亂碼問題。

為防止中文亂碼出現，首先我們要把項目中每個網頁的編碼形式改成中文的，HTML網頁中的charset改成UTF-8，JSP網頁中的pageEncoding改成UTF-8。

然后我們做一個過濾器，每次對網頁的請求都會進入到過濾器，并且把request和response都改成UTF-8編碼形式，這樣防止了中文亂碼的出現。

源代碼如下：

package com.dr.servletform;

import java.io.IOException;

import javax.servlet.Filter;

import javax.servlet.FilterChain;

import javax.servlet.FilterConfig;

import javax.servlet.ServletException;

import javax.servlet.ServletRequest;

import javax.servlet.ServletResponse;

import javax.servlet.jsp.jstl.core.Config;

public class MyFilter implements Filter{

       String encoding="";

       public void destroy() {

       }

       public void doFilter(ServletRequest request, ServletResponse response,

                     FilterChain chain) throws IOException, ServletException {

              System.out.println("pass here-------");

              request.setCharacterEncoding(encoding);

              response.setCharacterEncoding(encoding);

              chain.doFilter(request, response);

       }

       public void init(FilterConfig config) throws ServletException {

              String encoding=config.getInitParameter("encoding");

              this.encoding=encoding;

              System.out.println(encoding);

       }

}

web.xml中配置如下：

<filter>

 <filter-name>MyFilter</filter-name>

 <filter-class>com.dr.servletform.MyFilter</filter-class>

- <init-param>

 <param-name>encoding</param-name>

 <param-value>UTF-8</param-value>

 </init-param>

 </filter>

- <filter-mapping>

 <filter-name>MyFilter</filter-name>

 <url-pattern>/*</url-pattern>

 </filter-mapping>

 

JDBC是Java語言提供訪問和操作數據庫的一種途徑，通過使用JDBC可以操作任意的SQL語句，來訪問和操作數據庫

JDBC編程步驟：

       加載數據庫驅動（jar 文件）

       獲得數據庫連接

       創建語句 (SQL)

       執行查詢

       遍歷結果集

       關閉數據庫連接

示例小程序：

package com.dr.jdbc;

/**

 * DriverManager 驅動程序管理器 在數據庫和相應驅動程序之間建立連接

 * Connection 對象代表與數據庫的連接，也就是在已經加載的Driver和數據庫之間建立連接

 * Statement 提供在基層連接上運行SQL語句，并且訪問結果

 * ResultSet 在Statement執行SQL語句時，有時會返回ResultSet結果集，包含的是查詢的結果集

 */

import java.sql.Connection;

import java.sql.DriverManager;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.sql.Statement;

public class Test {

    public static void main(String[] args) {   

            query();

    }   

    public static void query(){   

            Connection conn = null;   

            try {

                       //1.加載數據庫驅動

                    Class.forName("com.mysql.jdbc.Driver");   

                    //2.獲得數據庫連接

                    //DriverManager 驅動程序管理器 在數據庫和相應驅動程序之間建立連

                    conn = DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/jdbc_db", "root", "1234"); 

                     //3.創建語句

                    String sql = "select * from UserTbl";   

                    //返回一個執行SQL的句柄

                    Statement stmt = conn.createStatement(); 

                    //返回查詢的

                    //4.執行語句

                    ResultSet rs = stmt.executeQuery(sql);

                    //5.遍歷結果集

                    while(rs.next()){   

                            int id = rs.getInt(1);   

                            String username = rs.getString(2);   

                            String password = rs.getString(3);   

                            int age = rs.getInt(4);   

                            System.out.println(id+":"+username+":"+password+":"+age);   

                    }   

            } catch (Exception e) {   

                    e.printStackTrace();   

            }finally{   

                    if(conn!=null){   

                            try {    //關閉數據庫連接

                                    conn.close();   

                            } catch (SQLException e) {   

                                    conn = null;   

                                    e.printStackTrace();   

                            }   

                    }   

            }   

    }

}

1.包含客戶端和服務器兩部分程序，并且兩個程序能分開獨立運行。
2.客戶端可以輸入服務器地址和端口，連接服務器。
3..服務器能接受客戶端連接，并向客戶端輸出發送的字符串。

代碼如下：
服務器端：

package com.dr.Demo01;

import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerSocket01 {

 public static void main(String[] args) {
  ServerSocket server=null;
  try{
   //服務器在9999端口開辟了服務
   server=new ServerSocket(9999);
  }catch(Exception e){}
  //對于服務器而言，所有用戶的請求都是通過SeverSocket實現
  Socket client=null;
  try{
   //服務器在此等待用戶的鏈接
   System.out.println("等待客戶端鏈接、、、");
   client=server.accept();//服務端接收到一個client
  }catch(Exception e){}
  //要向客戶端打印信息
  PrintStream out=null;
  //得到向客戶端輸出信息的能力
  try{
   out=new PrintStream(client.getOutputStream());
  }catch(Exception e){}
  out.println("Hi,how do you do?");
  try{
   client.close();
   server.close();
  }catch(Exception e){}
  System.out.println("客戶端回應完畢、、、");
 }

}

客戶端：

package com.dr.Demo01;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.Socket;

public class ClientSocket01 {

 public static void main(String[] args) {
 
  Socket client=null;
  try{
   //實際上表示要鏈接到服務器上去了
   client=new Socket("192.168.1.23",9999);
  }catch(Exception e){}
  //等待服務器端的回應
  String str=null;
  //如果直接使用InputStream接受會比較麻煩
  //最好的方法是可以把內容放入發哦緩沖流之中進行讀取
  BufferedReader buf=null;
  
  try{
   buf=new BufferedReader(new InputStreamReader(client.getInputStream()));
      str=buf.readLine();
  }catch(Exception e){}
  System.out.println(str);
 }

}

 

線程間通信：一個線程向數據存儲空間添加數據（Benz），另一個線程從數據存儲空間取出數據（BMW）。

程序有兩種以外需要考慮：

1、      假設Benz線程剛向數據存儲空間添加了一輛車的名字。還沒有加入這輛車的顏色，CPU就切換到了BMW線程，Benz線程將把這輛車的名字和上輛車的顏色聯系到了一起。

2、      Benz放了若干次的數據。BMW才開始取數據，或者是，BMW取完了一個數據后，還沒等到Benz放入新的數據，又重復取出已取過的數據。

可能出現的問題：

1、      Benz比BMW快時，BMW會漏掉一些數據沒有取到。

2、      BMW比Benz快時，BMW取相同的數據。

多個線程共享同一資源的時候，必須進行同步，采用同步方法，解決第一個問題。

線程的等待和喚醒機制：

wait()：告訴當前線程放棄監視器并進入睡眠狀態，直到其他線程進入同一監視器并調用notify為止。

notify()：喚醒同一對象監視器中調用wait的第一個線程。

程序中采用線程的等待和喚醒機制，當發現BMW沒有取走內容時，Benz應該等待，當BMW把內容取走之后，Benz才可以放。這樣解決了第二個問題。

 

代碼如下：

package com.dr.test;

 

class Car{

       private String name="奔馳";

       private String color="銀色";

       private boolean flag=false;

       public synchronized void set(String name,String color){

              //如果flag的值不是true則要等待

              if(!flag){

                     //等待

                     try{

                            wait();

                     }catch(Exception e){}

              }

              //如果向下繼續執行了，則表示可以設置，flag=true

              this.name=name;

              this.color=color;

              flag=false;

              notify();

       }

       public synchronized void get(){

              //如果flag的值為true的時候，表示要等待

              if(flag){

                     try{

                            wait();

                     }catch(Exception e){}

              }

              //如果向下執行了，則表示允許取出

              System.out.println(this.name+"-->"+this.color);

              //改變標志，表示可以生產了

              flag=true;

              notify();

       }

}

class Benz implements Runnable{

       Car car=null;

       public Benz(Car c){

              this.car=c;

       }

       public void run(){

              int i=0;

              while(true){

                     if(i==0){

                            car.set("寶馬", "紅色");

                            i=1;

                     }

                     else{

                            car.set("奔馳", "銀色");

                            i=0;

                     }

              }

       }

}

class BMW implements Runnable{

       Car car=null;

       public BMW(Car c){

              this.car=c;

       }

       public void run(){

              while(true){

                     car.get();

              }

       }

}

public class Demo01 {

 

      

       public static void main(String[] args) {

              Car c=new Car();

              Benz benz=new Benz(c);

              BMW bmw=new BMW(c);

              new Thread(benz).start();

              new Thread(bmw).start();

       }

 

}

 

運行結果：

 

 

 

Java線程的實現有兩種方式：

1 通過繼承Thread類來實現。

每個線程都是通過某個特定Thread對象所對應的方法run()l來完成其操作的，方法run()成為線程體。

如果想要啟動多線程，則肯定調用start()方法，start方法可以調用被子類覆寫過的run方法

不過這種這種實現方式會受到單繼承的局限

 

示例代碼：

package com.dr.demo01;

//一個類只要繼承了Thread類，則此類就是多線程類

class MyThread extends Thread{

       private String name;

       public MyThread(String name){

              this.name=name;

       }

       //如果要使用多線程，則必須有一個方法的主體

       public void run(){

              //打印輸出

              for(int i=0;i<15;i++){

                     System.out.println(this.name+"--->在運行、、、");

              }

       }

}

public class ThreadDemo01{

       public static void main(String args[]){

              MyThread mt1=new MyThread("線程A");

              MyThread mt2=new MyThread("線程B");

              MyThread mt3=new MyThread("線程C");

              mt1.run();

              mt2.run();

              mt3.run();

       }

}

 

2 通過實現Runnable接口來實現。

該實現方式有以下好處：

①     適合多個相干同程序代碼的線程去處理同一資源的情況。

②     可以避免由于Java單繼承特性帶來的局限。

③     有利于程序的健壯性，代碼能夠被多個線程共享。

 

示例代碼：

package com.dr.Demo05;

class MyThread implements Runnable{

    public void run(){

       for(int i=0;i<100;i++){

           try{

              Thread.sleep(1000);

           }catch(Exception e){}

           System.out.println(Thread.currentThread().getName()+"--運行中--");

       }

    }

}

public class Demo05 {

 

   

    public static void main(String[] args) {

       MyThread mt=new MyThread();

       Thread t1=new Thread(mt,"線程A");

       Thread t2=new Thread(mt,"線程B");

       Thread t3=new Thread(mt,"線程C");

       t1.start();

       t2.start();

       t3.start();

    }

 

}