java基础（五）：谈谈java中的多线程
2019-02-25 16:11:02来源：博客园 阅读 ()
1.多线程
1.1.多线程介绍
学习多线程之前，我们先要了解几个关于多线程有关的概念。
进程：正在运行的程序。确切的来说，当一个程序进入内存运行，即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能，进程是系统进行资源分配和调度的一个独立单位。进程是正在运行的程序，进程负责给程序分配内存空间，而每一个进程都是由程序代码组成的，这些代码在进程中执行的流程就是线程。
线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。
简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程，但至少有一个线程。什么是多线程呢？即就是一个程序中有多个线程在同时执行。
1.2.多线程运行原理
大部分操作系统都支持多进程并发运行，现在的操作系统几乎都支持同时运行多个任务。比如：现在我们上课一边使用编辑器，一边使用录屏软件，同时还开着画图板，dos窗口等软件。感觉这些软件好像在同时运行着。
其实这些软件在某一时刻，只会运行一个进程。这是为什么呢？这是由于CPU(中央处理器)在做着高速的切换而导致的。对于CPU而言，它在某个时间点上，只能执行一个程序，即就是说只能运行一个进程，CPU不断地在这些进程之间切换。只是我们自己感觉不到。为什么我们会感觉不到呢?这是因为CPU的执行速度相对我们的感觉实在太快了，虽然CPU在多个进程之间轮换执行，但我们自己感到好像多个进程在同时执行。
多线程真的能提高效率吗？其实并不是这样的，因为我们知道，CPU会在多个进程之间做着切换，如果我们开启的程序过多，CPU切换到每一个进程的时间也会变长，我们也会感觉机器运行变慢。所以合理的使用多线程可以提高效率，但是大量使用，并不能给我们带来效率上的提高。
1.3.主线程
回想我们以前学习中写过的代码，当我们在dos命令行中输入java空格类名回车后，启动JVM，并且加载对应的class文件。虚拟机并会从main方法开始执行我们的程序代码，一直把main方法的代码执行结束。如果在执行过程遇到循环时间比较长的代码，那么在循环之后的其他代码是不会被执行的。如下代码演示：
1 class Demo 2 { 3 String name; 4 Demo(String name) 5 { 6 this.name = name; 7 } 8 void show() 9 { 10 for (int i=1;i<=20 ;i++ ) 11 { 12 System.out.println("name="+name+",i="+i); 13 } 14 } 15 } 16 class ThreadDemo 17 { 18 public static void main(String[] args) 19 { 20 Demo d = new Demo("小强"); 21 Demo d2 = new Demo("旺财"); 22 d.show(); 23 d2.show(); 24 System.out.println("Hello World!"); 25 } 26 }
若在上述代码中show方法中的循环执行次数很多，这时书写在d.show();下面的代码是不会执行的，并且在dos窗口会看到不停的输出name=小强,i=值，这样的语句。为什么会这样呢？
原因是：jvm启动后，必然有一个执行路径(线程)从main方法开始的。一直执行到main方法结束。这个线程在java中称之为主线程。当主线程在这个程序中执行时，如果遇到了循环而导致程序在指定位置停留时间过长，无法执行下面的程序。
可不可以实现一个主线程负责执行其中一个循环，由另一个线程负责其他代码的执行。实现多部分代码同时执行。这就是多线程技术可以解决的问题。
1.4.如何创建线程
1.4.1.创建线程方式一：继承Thread类
该如何创建线程呢？通过API中的英文Thread的搜索，查到Thread类。通过阅读Thread类中的描述。创建新执行线程有两种方法。一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。
创建线程的步骤：
1. 定义一个类继承Thread。
2. 重写run方法。
3. 创建子类对象，就是创建线程对象。
4. 调用start方法，开启线程并让线程执行，同时还会告诉jvm去调用run方法。
1 class Demo extends Thread //继承Thread 2 { 3 String name; 4 Demo(String name) 5 { 6 this.name = name; 7 } 8 //复写其中的run方法 9 public void run() 10 { 11 for (int i=1;i<=20 ;i++ ) 12 { 13 System.out.println("name="+name+",i="+i); 14 } 15 } 16 } 17 class ThreadDemo 18 { 19 public static void main(String[] args) 20 { 21 //创建两个线程任务 22 Demo d = new Demo("小强"); 23 Demo d2 = new Demo("旺财"); 24 //d.run(); 这里仍然是主线程在调用run方法，并没有开启两个线程 25 //d2.run(); 26 d2.start();//开启一个线程 27 d.run();//主线程在调用run方法 28 } 29 }
打印部分结果：由于多线程操作，输出数据会有所不同
name=旺财,i=1
name=小强,i=1
name=旺财,i=2
name=小强,i=2
name=小强,i=3
name=旺财,i=3
name=旺财,i=4
name=旺财,i=5
name=旺财,i=6
name=旺财,i=7
..........
思考：线程对象调用 run方法和调用start方法区别？
线程对象调用run方法不开启线程。仅是对象调用方法。线程对象调用start开启线程，并让jvm调用run方法在开启的线程中执行。
1.4.2.继承Thread类原理
为什么要继承Thread类，并调用其的start方法才能开启线程呢？
继承Thread类：因为Thread类描述线程事物，具备线程应该有功能。
那为什么不直接创建Thread类的对象呢？
1 Thread t1 = new Thread(); 2 t1.start();//这样做没有错，但是该start调用的是Thread类中的run方法，而这个run方法没有做什么事情，更重要的是这个run方法中并没有定义我们需要让线程执行的代码。
创建线程的目的是什么？
是为了建立单独的执行路径，让多部分代码实现同时执行。也就是说线程创建并执行需要给定的代码(线程的任务)。对于之前所讲的主线程，它的任务定义在main函数中。自定义线程需要执行的任务都定义在run方法中。Thread类中的run方法内部的任务并不是我们所需要，只有重写这个run方法，既然Thread类已经定义了线程任务的位置，只要在位置中定义任务代码即可。所以进行了重写run方法动作。
1.5.多线程的内存图解
多线程执行时，到底在内存中是如何运行的呢？
以上个程序为例，进行图解说明：
多线程执行时，在栈内存中，其实每一个执行线程都有一片自己所属的栈内存空间。进行方法的压栈和弹栈。
当执行线程的任务结束了，线程自动在栈内存中释放了。但是当所有的执行线程都结束了，那么进程就结束了。
1.6.获取线程名称
开启的线程都会有自己的独立运行栈内存，那么这些运行的线程的名字是什么呢？该如何获取呢？既然是线程的名字，按照面向对象的特点，是哪个对象的属性和谁的功能，那么我们就去找那个对象就可以了。查阅Thread类的API文档发现有个方法是获取当前正在运行的线程对象。还有个方法是获取当前线程对象的名称。既然找到了，我们就可以试试。
Thread.currentThread()获取当前线程对象
Thread.currentThread().getName();获取当前线程对象的名称
1 class Demo extends Thread //继承Thread 2 { 3 String name; 4 Demo(String name) 5 { 6 this.name = name; 7 } 8 //复写其中的run方法 9 public void run() 10 { 11 for (int i=1;i<=20 ;i++ ) 12 { 13 System.out.println("name="+name+","+Thread.currentThread().getName()+",i="+i); 14 } 15 } 16 } 17 class ThreadDemo 18 { 19 public static void main(String[] args) 20 { 21 //创建两个线程任务 22 Demo d = new Demo("小强"); 23 Demo d2 = new Demo("旺财"); 24 d2.start();//开启一个线程 25 d.run();//主线程在调用run方法 26 } 27 }
原来主线程的名称： main
自定义的线程： Thread-0 线程多个时，数字顺延。Thread-1......
进行多线程编程时不要忘记了Java程序运行时从主线程开始，main方法的方法体就是主线程的线程执行体。
1.7.创建线程的第二种方式
掌握了如何创建线程对象，以及开启线程后，记得在查阅API时，还说了有第二种开启线程的方式，那么第二种是什么呢？
1.7.1.实现Runnable接口
继续查看API发现，创建线程的另一种方法是声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。
怎么还要实现Runnable接口，Runable是啥玩意呢？继续API搜索。
查看Runnable接口说明文档：Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
总结：
创建线程的第二种方式：实现Runnable接口。
1、定义类实现Runnable接口。
2、覆盖接口中的run方法。。
3、创建Thread类的对象
4、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
5、调用Thread类的start方法开启线程。
1 代码演示： 2 class Demo implements Runnable 3 { 4 private String name; 5 Demo(String name) 6 { 7 this.name = name; 8 } 9 //覆盖了接口Runnable中的run方法。 10 public void run() 11 { 12 for(int i=1; i<=20; i++) 13 { System.out.println("name="+name+"..."+Thread.currentThread().getName()+"..."+i); 14 } 15 } 16 } 17 class ThreadDemo2 18 { 19 public static void main(String[] args) 20 { 21 //创建Runnable子类的对象。注意它并不是线程对象。 22 Demo d = new Demo("Demo"); 23 //创建Thread类的对象，将Runnable接口的子类对象作为参数传递给Thread类的构造函数。 24 Thread t1 = new Thread(d); 25 Thread t2 = new Thread(d); 26 //将线程启动。 27 t1.start(); 28 t2.start(); 29 System.out.println(Thread.currentThread().getName()+"----->"); 30 System.out.println("Hello World!"); 31 } 32 }
输出结果：
1.7.2.实现Runnable的原理
为什么需要定一个类去实现Runnable接口呢？继承Thread类和实现Runnable接口有啥区别呢？
实现Runnable接口，避免了继承Thread类的单继承局限性。覆盖Runnable接口中的run方法，将线程任务代码定义到run方法中。创建Thread类的对象，只有创建Thread类的对象才可以创建线程。线程任务已被封装到Runnable接口的run方法中，而这个run方法所属于Runnable接口的子类对象，所以将这个子类对象作为参数传递给Thread的构造函数，这样，线程对象创建时就可以明确要运行的线程的任务。
1.7.3.实现Runnable的好处
第二种方式实现Runnable接口避免了单继承的局限性，所以较为常用。实现Runnable接口的方式，更加的符合面向对象，线程分为两部分，一部分线程对象，一部分线程任务。继承Thread类，线程对象和线程任务耦合在一起。一旦创建Thread类的子类对象，既是线程对象，有又有线程任务。实现runnable接口，将线程任务单独分离出来封装成对象，类型就是Runnable接口类型。Runnable接口对线程对象和线程任务进行解耦。
1.8.线程状态图
查阅API关于IllegalThreadStateException这个异常说明信息发现，这个异常的描述信息为：指示线程没有处于请求操作所要求的适当状态时抛出的异常。这里面说适当的状态，啥意思呢？难道是说线程还有状态吗？
1、新建（new）：线程对象被创建后就进入了新建状态。如：Thread thread = new Thread();
2、就绪状态（Runnable）：也被称为“可执行状态”。线程对象被创建后，其他线程调用了该对象的start()方法，从而启动该线程。如：thread.start(); 处于就绪状态的线程随时可能被CPU调度执行。
3、运行状态（Running）：线程获取CPU权限进行执行。需要注意的是，线程只能从就绪状态进入到运行状态。
4、阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权限，暂时停止运行。直到线程进入就绪状态，才有机会进入运行状态。阻塞的三种情况：
1）等待阻塞：通过调用线程的wait()方法，让线程等待某工作的完成。
2）同步阻塞：线程在获取synchronized同步锁失败（因为锁被其他线程占用），它会进入同步阻塞状态。
3）其他阻塞：通过调用线程的sleep()或join()或发出了I/O请求时，线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或超时、或者I/O处理完毕时，线程重新转入就绪状态。
5、死亡状态（Dead）：线程执行完了或因异常退出了run()方法，该线程结束生命周期。
1.8.1.sleep,wait,yield,join的区别
1.sleep()方法
在指定时间内让当前正在执行的线程暂停执行，但不会释放“锁标志”。不推荐使用。
sleep()使当前线程进入阻塞状态，在指定时间内不会执行。
2.wait()方法
在其他线程调用对象的notify或notifyAll方法前，导致当前线程等待。线程会释放掉它所占有的“锁标志”，从而使别的线程有机会抢占该锁。
当前线程必须拥有当前对象锁。如果当前线程不是此锁的拥有者，会抛出IllegalMonitorStateException异常。
唤醒当前对象锁的等待线程使用notify或notifyAll方法，也必须拥有相同的对象锁，否则也会抛出IllegalMonitorStateException异常。
waite()和notify()必须在synchronized函数或synchronized block中进行调用。如果在non-synchronized函数或non-synchronized block中进行调用，虽然能编译通过，但在运行时会发生IllegalMonitorStateException的异常。
3.yield方法
暂停当前正在执行的线程对象。
yield()只是使当前线程重新回到可执行状态，所以执行yield()的线程有可能在进入到可执行状态后马上又被执行。
yield()只能使同优先级或更高优先级的线程有执行的机会。
调用yield方法并不会让线程进入阻塞状态，而是让线程重回就绪状态，它只需要等待重新获取CPU执行时间，这一点是和sleep方法不一样的。
4.join方法
等待该线程终止。
等待调用join方法的线程结束，再继续执行。如：t.join();//主要用于等待t线程运行结束，若无此句，main则会执行完毕，导致结果不可预测
1.9.线程的安全问题
带女朋友看电影，需要买票，电影院要卖票，模拟电影院的买票操作
假设我们想要的电影是 “功夫熊猫3”，本次电影的座位共100个(本厂电影只能卖100张票)
模拟电影院的售票窗口，实现多个窗口同时卖 “功夫熊猫3”这场电影票(多个窗口一起卖这100张票)
需要窗口：采用线程对象
需要票：Runnable接口子类来模拟
1 public class ThreadDemo { 2 public static void main(String[] args) { 3 //创建票对象 4 Ticket ticket = new Ticket(); 5 6 //创建3个窗口 7 Thread t1 = new Thread(ticket, "窗口1"); 8 Thread t2 = new Thread(ticket, "窗口2"); 9 Thread t3 = new Thread(ticket, "窗口3"); 10 11 t1.start(); 12 t2.start(); 13 t3.start(); 14 } 15 } 16 17 public class Ticket implements Runnable { 18 //共100票 19 int ticket = 100; 20 21 @Override 22 public void run() { 23 //模拟卖票 24 while(true){ 25 //t1,t2,t3 26 if (ticket > 0) { 27 //模拟选坐的操作 28 try { 29 Thread.sleep(1); 30 } catch (InterruptedException e) { 31 e.printStackTrace(); 32 } 33 System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--); 34 } 35 } 36 } 37 }
总结：上面程序出新了问题
票出现了重复的票
错误的票 0
1.10.同步的锁
同步代码块: 在代码块声明上 加上synchronized
1 synchronized (锁对象) { 2 可能会产生线程安全问题的代码 3 }
同步代码块中的锁对象可以是任意的对象，多个线程对象使用的是同一个锁对象
把Ticket.java进行了代码修改
1 public class Ticket implements Runnable { 2 //共100票 3 int ticket = 100; 4 5 //定义所对象 6 Object lock = new Object(); 7 @Override 8 public void run() { 9 //模拟卖票 10 while(true){ 11 //同步代码块 12 synchronized (lock){ 13 if (ticket > 0) { 14 //模拟选坐的操作 15 try { 16 Thread.sleep(10); 17 } catch (InterruptedException e) { 18 e.printStackTrace(); 19 } 20 System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--); 21 } 22 } 23 } 24 } 25 }
当使用了同步代码块后，上述的线程的安全问题，解决了。
同步方法：在方法声明上加上synchronized
1 public synchronized void method(){ 2 3 可能会产生线程安全问题的代码 4 5 }
同步方法中的锁对象是 this
1 //同步方法,锁对象this 2 public synchronized void method(){ 3 //this.name = name; 4 if (ticket > 0) { 5 //模拟选坐的操作 6 try { 7 Thread.sleep(10); 8 } catch (InterruptedException e) { 9 e.printStackTrace(); 10 } 11 System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--); 12 } 13 }
静态同步方法: 在方法声明上加上synchronized
1 public static synchronized void method(){ 2 可能会产生线程安全问题的代码 3 }
1.11.死锁
同步锁的另一个弊端：当线程任务中出现了多个同步(多个锁)时，如果同步中嵌套了其他的同步。这时容易引发一种现象：死锁。这种情况能避免就避免掉。
1 synchronzied(A锁){ 2 synchronized(B锁){ 3 4 } 5 }
1 /* 2 * 定义锁对象 3 */ 4 public class MyLock { 5 public static final Object lockA = new Object(); 6 public static final Object lockB = new Object(); 7 } 8 9 /* 10 * 线程任务类 11 */ 12 public class ThreadTask implements Runnable { 13 14 int x = new Random().nextInt(1);//0,1 15 16 //指定线程要执行的任务代码 17 @Override 18 public void run() { 19 while(true){ 20 if (x%2 ==0) { 21 //情况一 22 synchronized (MyLock.lockA) { 23 System.out.println("if-LockA"); 24 synchronized (MyLock.lockB) { 25 System.out.println("if-LockB"); 26 System.out.println("if大口吃肉"); 27 } 28 } 29 } else { 30 //情况二 31 synchronized (MyLock.lockB) { 32 System.out.println("else-LockB"); 33 synchronized (MyLock.lockA) { 34 System.out.println("else-LockA"); 35 System.out.println("else大口吃肉"); 36 } 37 } 38 } 39 x++; 40 } 41 } 42 } 43 44 public class ThreadDemo { 45 public static void main(String[] args) { 46 //创建线程任务类对象 47 ThreadTask task = new ThreadTask(); 48 49 //创建两个线程 50 Thread t1 = new Thread(task); 51 Thread t2 = new Thread(task); 52 53 //启动线程 54 t1.start(); 55 t2.start(); 56 } 57 }
1.12.Lock接口
查阅API，发现Lock接口，比同步更厉害，有更多操作；
lock():获取锁
unlock():释放锁；
提供了一个更加面对对象的锁，在该锁中提供了更多的显示的锁操作。使用Lock接口，以及其中的lock()方法和unlock()方法替代同步。
如下代码演示：
1 public class Ticket implements Runnable { 2 //共100票 3 int ticket = 100; 4 5 //创建Lock锁对象 6 Lock ck = new ReentrantLock(); 7 8 @Override 9 public void run() { 10 //模拟卖票 11 while(true){ 12 //synchronized (lock){ 13 ck.lock(); 14 if (ticket > 0) { 15 //模拟选坐的操作 16 try { 17 Thread.sleep(10); 18 } catch (InterruptedException e) { 19 e.printStackTrace(); 20 } 21 System.out.println(Thread.currentThread().getName() + "正在卖票:" + ticket--); 22 } 23 ck.unlock(); 24 //} 25 } 26 } 27 }
1.13.线程的匿名内部类的使用
1 方式1 2 new Thread() { 3 public void run() { 4 for (int x = 0; x < 40; x++) { 5 System.out.println(Thread.currentThread().getName() 6 + "...X...." + x); 7 } 8 } 9 }.start(); 10 11 方式2 12 Runnable r = new Runnable() { 13 public void run() { 14 for (int x = 0; x < 40; x++) { 15 System.out.println(Thread.currentThread().getName() 16 + "...Y...." + x); 17 } 18 } 19 }; 20 new Thread(r).start();
2.多线程文件上传
实现服务器端可以同时接收多个客户端上传的文件。 我们要修改服务器端代码
1 /* 2 * 文件上传 服务器端 3 * 4 */ 5 public class TCPServer { 6 public static void main(String[] args) throws IOException { 7 //1,创建服务器，等待客户端连接 8 ServerSocket serverSocket = new ServerSocket(6666); 9 10 //实现多个客户端连接服务器的操作 11 while(true){ 12 final Socket clientSocket = serverSocket.accept(); 13 //启动线程，完成与当前客户端的数据交互过程 14 new Thread(){ 15 public void run() { 16 try{ 17 //显示哪个客户端Socket连接上了服务器 18 InetAddress ipObject = clientSocket.getInetAddress();//得到IP地址对象 19 String ip = ipObject.getHostAddress(); //得到IP地址字符串 20 System.out.println("小样，抓到你了，连接我！！" + "IP:" + ip); 21 22 //7,获取Socket的输入流 23 InputStream in = clientSocket.getInputStream(); 24 //8,创建目的地的字节输出流 D:\\upload\\192.168.74.58(1).jpg 25 BufferedOutputStream fileOut = new BufferedOutputStream(new FileOutputStream("D:\\upload\\"+ip+"("+System.currentTimeMillis()+").jpg")); 26 //9,把Socket输入流中的数据，写入目的地的字节输出流中 27 byte[] buffer = new byte[1024]; 28 int len = -1; 29 while((len = in.read(buffer)) != -1){ 30 //写入目的地的字节输出流中 31 fileOut.write(buffer, 0, len); 32 } 33 34 //-----------------反馈信息--------------------- 35 //10,获取Socket的输出流, 作用：写反馈信息给客户端 36 OutputStream out = clientSocket.getOutputStream(); 37 //11,写反馈信息给客户端 38 out.write("图片上传成功".getBytes()); 39 40 out.close(); 41 fileOut.close(); 42 in.close(); 43 clientSocket.close(); 44 } catch(IOException e){ 45 e.printStackTrace(); 46 } 47 }; 48 }.start(); 49 } 50 51 //serverSocket.close(); 52 } 53 }
3.总结
创建线程的方式
方式1，继承Thread线程类
步骤
1， 自定义类继承Thread类
2， 在自定义类中重写Thread类的run方法
3， 创建自定义类对象(线程对象)
4， 调用start方法，启动线程，通过JVM，调用线程中的run方法
方式2，实现Runnable接口
步骤
1， 创建线程任务类 实现Runnable接口
2， 在线程任务类中 重写接口中的run方法
3， 创建线程任务类对象
4， 创建线程对象，把线程任务类对象作为Thread类构造方法的参数使用
5， 调用start方法，启动线程，通过JVM，调用线程任务类中的run方法
同步锁
多个线程想保证线程安全，必须要使用同一个锁对象
A.同步代码块
1 synchronized (锁对象){ 2 可能产生线程安全问题的代码 3 }
同步代码块的锁对象可以是任意的对象
B.同步方法
1 public synchronized void method() 2 可能产生线程安全问题的代码 3 }
同步方法中的锁对象是 this
C.静态同步方法
1 public synchronized void method() 2 可能产生线程安全问题的代码 3 }
静态同步方法中的锁对象是 类名.class
参考：
java编程思想
黑马教学视频
https://www.cnblogs.com/huangzhe1515023110/p/9276097.html
https://blog.csdn.net/qq_38545713/article/details/79778930
原文链接:https://www.cnblogs.com/dz-boss/p/10421951.html
如有疑问请与原作者联系
标签：
版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有
上一篇：HashMap源码分析
下一篇：Java学到什么程度才能叫精通？
- 国外程序员整理的Java资源大全（全部是干货） 2020-06-12
- 2020年深圳中国平安各部门Java中级面试真题合集（附答案） 2020-06-11
- 2020年java就业前景 2020-06-11
- 04.Java基础语法 2020-06-11
- Java--反射(框架设计的灵魂)案例 2020-06-11
IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash
