多线程

世间万物都可以同时完成很多工作，例如，人体可以同时进行呼吸、血液循环、思考问题等活动，用户既可以使用计算机听歌，也可以使用它打印文件，而这些活动完全可以同时进行，这种思想放在Java中被称为并发，而将并发完成的每一件事情称为线程。 在Java中，并发机制非常重要，但并不是所有的程序语言都支持线程。在以往的程序中，多以一个任务完成后再进行下一个项目的模式进行开发，这样下一个任务的开始必须等待前一个任务的结束。Java语言提供了并发机制，程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其

多线程

• 如果一次只完成一件事情，很容易实现。但现实生活中，很多事情都是同时进行的。Java中为了模拟这种状态，引入了线程机制。简单地说，当程序同时完成多件事情时，就是所谓的多线程程序。多线程应用相当广泛，使用多线程可以创建窗口程序、网络程序等。
• 一、 线程简介
  • 世间万物都可以同时完成很多工作，例如，人体可以同时进行呼吸、血液循环、思考问题等活动，用户既可以使用计算机听歌，也可以使用它打印文件，而这些活动完全可以同时进行，这种思想放在Java中被称为并发，而将并发完成的每一件事情称为线程。 在Java中，并发机制非常重要，但并不是所有的程序语言都支持线程。在以往的程序中，多以一个任务完成后再进行下一个项目的模式进行开发，这样下一个任务的开始必须等待前一个任务的结束。Java语言提供了并发机制，程序员可以在程序中执行多个线程，每一个线程完成一个功能，并与其他线程并发执行，这种机制被称为多线程。 多线程是非常复杂的机制，比如同时阅读3本书，首先阅读第1本书第1章，然后再阅读第2本书第1章，再阅读第3本书第1章，回过头再阅读第1本书第2章，依此类推，就体现了多线程的复杂性。 既然多线程这样复杂，那么它在操作系统中是怎样工作的呢？其实Java中的多线程在每个操作系统中的运行方式也存在差异，在此着重说明多线程在Windows操作系统中的运行模式。Windows操作系统是多任务操作系统，它以进程为单位。一个进程是一个包含有自身地址的程序，每个独立执行的程序都称为进程，也就是正在执行的程序。系统可以分配给每个进程一段有限的使用CPU的时间（也可以称为CPU时间片），CPU在这段时间中执行某个进程，然后下一个时间片又跳至另一个进程中去执行。由于CPU转换较快，所以使得每个进程好像是同时执行一样。 一个线程则是进程中的执行流程，一个进程中可以同时包括多个线程，每个线程也可以得到一小段程序的执行时间，这样一个进程就可以具有多个并发执行的线程。在单线程中，程序代码按调用顺序依次往下执行，如果需要一个进程同时完成多段代码的操作，就需要产生多线程。
• 二、 实现线程的两种方式
  • 1||| 继承Thread类：Thread类是java.lang包中的一个类，从这个类中实例化的对象代表线程，程序员启动一个新线程需要建立Thread实例。Thread类中常用的两个构造方法如下
    • I. public Thread():创建一个新的线程对象
    • II. public Thread(String threadName):创建一个名称为threadName的线程对象
    • 继承Thread类创建一个新的线程的语法如下： public class ThreadTest extends Thread{ } 完成线程真正功能的代码放在类的run()方法中，当一个类继承Thread类后，就可以在该类中覆盖run()方法，将实现该线程功能的代码写入run()方法中，然后同时调用Thread类中的start()方法执行线程，也就是调用run()方法。 Thread对象需要一个任务来执行，任务是指线程在启动时执行的工作，该工作的功能代码被写在run()方法中。run()方法必须使用以下语法格式： public void run( ){ }
      • 如果start（）方法调用一个已经启动的线程，系统将抛出IllegalThreadStateException异常
      • 当执行一个线程程序时，就自动产生一个线程，主方法正是在这个线程上运行的。当不再启动其他线程时，该程序就为单线程程序。主方法线程启动由Java虚拟机负责，程序员负责启动自己的线程。代码如下： public static void main(String[] args){ new ThreadTest().start(); }
        • 继承Thread类实例代码: package com.THREAD; public class ThreadTest extends Thread{ private int count=10; public void run(){ //重写run（）方法 while(true){ System.out.println(count+""); if (--count==0){ break; } } } public static void main(String[] args) { new ThreadTest().start(); } }
          • 在上述实例中，继承了Thread类，然后在类中覆盖了run()方法。通常在run()方法中使用无限循环的形式，使得线程一直运行下去，所以要指定一个跳出循环的条件，如本实例中使用变量count递减为0作为跳出循环的条件。 在main方法中，使线程执行需要调用Thread类中的start()方法，start()方法调用被覆盖的run()方法，如果不调用start()方法，线程永远都不会启动，在主方法没有调用start()方法之前，Thread对象只是一个实例，而不是一个真正的线程。
          • 运行结果: 10 9 8 7 6 5 4 3 2 1
  • 2||| 实现Runnable接口：到目前为止，线程都是通过扩展Thread类来创建的，如果程序员需要继承其他类（非Thread类）,而且还要使当前类实现多线程，那么可以通过Runnable接口来实现。例如，一个扩展JFrame类的GUI程序不可能再继承Thread类，因为Java语言中不支持多继承，这时该类就需要实现Runnable接口使其具有使用线程的功能。实现Runnable接口的语法如下： public class Thread extends Object implements Runnable
    • 实质上Thread类实现了Runnable接口，其中的run()方法正是对Runnable接口中的run()方法的具体实现。
    • 实现Runnable接口的程序会创建一个Thread对象，并将Runnable对象与Thread对象相关联。Thread类中有以下两个构造方法：
      • I. public Thread(Runnable target)
      • II. public Thread(Runnable target,String name)
      • 这两个构造方法的参数中都存在Runnable实例，使用以上构造方法就可以将Runnable实例与Thread实例相关联。 使用Runnable接口启动新的线程的步骤如下： （1）建立Runnable对象。 （2）使用参数为Runnable对象的构造方法创建Thread实例。 （3）调用start()方法启动线程。
        • 通过Runnable接口创建线程时程序员首先需要编写一个实现Runnable接口的类，然后实例化该类的对象，这样就建立了Runnable对象；接下来使用相应的构造方法创建Thread实例；最后使用该实例调用Thread类中的start()方法启动线程。右图表明了实现Runnable接口创建线程的流程。
          • • 实例代码： package com.THREAD; import javax.swing.*; import java.awt.*; import java.net.URL; public class SwingAndThread extends JFrame { JFrame jFrame=new JFrame(); private JLabel jl=new JLabel(); //声明JLabel对象 private static Thread t; //声明线程对象 private int count=0; //声明计数器变量 private Container container=jFrame.getContentPane(); //获取容器 public SwingAndThread() { jFrame.setLayout(null); //窗体不使用布局管理器 jFrame.setBounds(300,200,480,360); //设置定位窗体大小与位置 URL url=SwingAndThread.class.getResource("冰棍.png"); //获取图片的URL ImageIcon image=new ImageIcon(url); //实例化一个Icon Image img=image.getImage(); img=img.getScaledInstance(50,50,Image.SCALE_DEFAULT); //设置图片缩放 image.setImage(img); jl.setIcon(image); //将图标添加到标签中 jl.setHorizontalAlignment(SwingConstants.LEFT); //设置图片在标签的最左方 jl.setBounds(20,20,200,200); //设置标签的大小与位置 jFrame.add(jl); jl.setOpaque(true); //设置标签为不透明 t=new Thread(new Runnable() { @Override //定义匿名内部类，该类实现Runnablejiekou public void run() { //重写run（）方法 while(count<=220) { jl.setBounds(count,count,50,50); //将标签的横纵坐标使用变量表示 try{ Thread.sleep(100); //使线程休眠1000毫秒 }catch(Exception e) { e.printStackTrace(); } count+=5; //坐标每次增加5 if(count==220) { count=10; //当图标移动到边界后重置图标位置 } } } }); t.start(); //启动线程 jFrame.setVisible(true); jFrame.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); } public static void main(String[] args) { new SwingAndThread(); } }
              • 启动一个新的线程，不是直接调用Thread子类对象的run()方法，而是调用Thread子类的start()方法，Thread类的start()方法产生一个新的线程，该线程运行Thread子类的run()方法。
              • 运行结果：
                • 在本实例中，为了使图标具有滚动功能，需要在类的构造方法中创建Thread实例。在创建该实例的同时需要Runnable对象作为Thread类构造方法的参数，然后使用内部类形式实现run()方法。在run()方法中主要循环图标的横坐标位置，当图标横坐标到达标签的最右下方时，再次将图标的横坐标置于图标滚动的初始位置。
• 三、 线程的生命周期
  • 线程具有生命周期，其中包含7种状态，分别为出生状态、就绪状态、运行状态、等待状态、休眠状态、阻塞状态和死亡状态。出生状态就是线程被创建时处于的状态，在用户使用该线程实例调用start()方法之前线程都处于出生状态；当用户调用start()方法后，线程处于就绪状态（又被称为可执行状态）；当线程得到系统资源后就进入运行状态。 一旦线程进入可执行状态，它会在就绪与运行状态下转换，同时也有可能进入等待、休眠、阻塞或死亡状态。当处于运行状态下的线程调用Thread类中的wait()方法时，该线程便进入等待状态，进入等待状态的线程必须调用Thread类中的notify()方法才能被唤醒，而notifyAll()方法是将所有处于等待状态下的线程唤醒；当线程调用Thread类中的sleep()方法时，则会进入休眠状态。如果一个线程在运行状态下发出输入／输出请求，该线程将进入阻塞状态，在其等待输入／输出结束时线程进入就绪状态，对于阻塞的线程来说，即使系统资源空闲，线程依然不能回到运行状态。当线程的run()方法执行完毕时，线程进入死亡状态。
    • 线程的生命周期状态图
      • 虽然多线程看起来像同时执行，但事实上在同一时间点上只有一个线程被执行，只是线程之间切换较快，所以才会使人产生线程是同时进行的假象。在Windows操作系统中，系统会为每个线程分配一小段CPU时间片，一旦CPU时间片结束就会将当前线程换为下一个线程，即使该线程没有结束。
      • 使线程处于就绪状态有以下几种方法
        • （1） 调用sleep()方法
        • （2） 调用wait()方法
        • （3） 等待输入/输出完成
        • 当线程处于就绪状态后，可以用以下几种方法使线程再次进入运行状态
          • （1） 线程调用notify（）方法
          • （2） 线程调用notifyAll（）方法
          • （3） 线程调用interrupt（）方法
          • （4） 线程的休眠时间结束
          • （5） 输入/输出结束
• 四、 操作线程的方法
  • 操作线程有很多方法，这些方法可以使线程从某一种状态过渡到另一种状态。
    • 1. 线程的休眠：一种能控制线程行为的方法是调用sleep()方法，sleep()方法需要一个参数用于指定该线程休眠的时间，该时间以毫秒为单位。在前面的实例中已经演示过sleep()方法，它通常是在run()方法内的循环中被使用。语法如下： try{ Thread.sleep(2000); }catch(InterruptedException e) { e.printStackTrace(); } 上述代码会使线程在2秒之内不会进入就绪状态。由于sleep()方法的执行有可能抛出InterruptedException异常，所以将sleep()方法的调用放在try-catch块中。虽然使用了sleep()方法的线程在一段时间内会醒来，但是并不能保证它醒来后进入运行状态，只能保证它进入就绪状态。
      • package com.THREAD; import javax.swing.*; import java.awt.*; import java.util.Random; public class SleepMethodTest extends JFrame { private Thread t; private static Color[] colors={Color.cyan,Color.BLACK,Color.BLUE,Color.GREEN,Color.ORANGE,Color.YELLOW,Color.RED ,Color.PINK,Color.GRAY,Color.MAGENTA}; //定义颜色数组 private static final Random rand=new Random(); //创建随机对象 private static Color getC() { return colors[rand.nextInt(colors.length)]; } public SleepMethodTest() { t=new Thread(new Runnable(){ //创建匿名线程对象 int x=30; int y=50; @Override public void run() //覆盖线程接口方法 { while (true) { try{ Thread.sleep(100); //线程休眠0.1秒 }catch(InterruptedException e) { e.printStackTrace(); } Graphics graphics=getGraphics(); //获取组件绘图上下文对象 graphics.setColor(getC()); //设置绘图颜色 graphics.drawLine(x,y,400,y++); //绘制直线并递增垂直坐标 if(y>=300) { y=50; } } } }); t.start(); } public static void init(JFrame frame,int width,int height) { //初始化程序界面方法 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(width,height); frame.setVisible(true); } public static void main(String[] args) { init(new SleepMethodTest(),480,360); } }
        • 在本实例中定义了getC()方法，该方法用于随机产生Color类型的对象，并且在产生线程的匿名内部类中使用getGraphics()方法获取Graphics对象，使用该对象调用setColor()方法为图形设置颜色；调用drawLine()方法绘制一条线段，同时线段会根据纵坐标的变化自动调整。
        • 运行结果：
    • 2. 线程的加入：如果当前某程序为多线程程序，假如存在一个线程A，现在需要插入线程B，并要求线程B先执行完毕，然后再继续执行线程A，此时可以使用Thread类中的join()方法来完成。这就好比此时你正在看电视，突然有人上门收水费，你必须付完水费后才能继续看电视。 当某个线程使用join()方法加入到另外一个线程时，另一个线程会等待该线程执行完毕后再继续执行。
      • 实例代码： package com.THREAD; import javax.swing.*; import java.awt.*; public class JoinTest extends JFrame { private Thread thread1; private Thread thread2; //定义两个线程 final JProgressBar progressBar1=new JProgressBar(); final JProgressBar progressBar2=new JProgressBar(); //定义两个进度条组件 int count=0; public JoinTest() { JFrame frame=new JFrame("线程的加入实例"); Container container=frame.getContentPane(); //获取容器 progressBar1.setStringPainted(true); progressBar2.setStringPainted(true); //设置进度条显示数字字符 frame.add(progressBar1,BorderLayout.NORTH); //将进度条设置在窗体北方 frame.add(progressBar2,BorderLayout.SOUTH); //将进度条设置在窗体南方 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setSize(580, 460); frame.setVisible(true); thread1=new Thread(new Runnable() { int count=0; @Override public void run() { while(true) { progressBar1.setValue(++count); //设置进度条的当前值 try{ Thread.sleep(100); //线程休眠0.1秒 thread2.join(); //使线程2加入战斗 }catch(InterruptedException e) { e.printStackTrace(); } } } }); thread1.start(); thread2=new Thread(new Runnable() { int count=0; @Override public void run() { while(true) { progressBar2.setValue(++count); try { Thread.sleep(100); }catch(InterruptedException e) { e.printStackTrace(); } if (count==100) { break; } } } }); thread2.start(); } public static void main(String[] args) { new JoinTest(); } }
        • 在本实例中同时创建了两个线程，这两个线程分别负责进度条的滚动。在线程A的run()方法中使线程B的对象调用join()方法，而join()方法使当前运行线程暂停，直到调用join()方法的线程执行完毕后再执行，所以线程A等待线程B执行完毕后再开始执行，即下面的进度条滚动完毕后上面的进度条才开始滚动。
        • 运行结果：
    • 3. 线程的中断：以往有的时候会使用stop()方法停止线程，但新版本的JDK早已废除了stop()方法，不建议使用stop()方法来停止一个线程的运行。现在提倡在run()方法中使用无限循环的形式，然后使用一个布尔型标记控制循环的停止。例如： public class InterruptedTest implement Runnable{ private boolean isOver=false; //标记一个变量，默认值为false public void run(){ //重写run()方法 while(true){ //...... if(isOver){ break; } } } public void setOver(){ this.isOver=true; } } 如果线程是因为使用了sleep()或wait()方法进入了就绪状态，可以使用Thread类中interrupt()方法使线程离开run()方法，同时结束线程，但程序会抛出InterruptedException异常，用户可以在处理该异常时完成线程的中断业务处理，如终止while循环。 下面的实例演示了某个线程使用interrupted()方法，同时程序抛出了InterruptedException异常，在异常处理时结束了while循环。在项目中，经常在这里执行关闭数据库连接和关闭Socket连接等操作。
      • 实例代码： package com.THREAD; import javax.swing.*; import java.awt.*; public class InterruptedSwing extends JFrame{ Thread thread; public InterruptedSwing() { JFrame frame=new JFrame("线程中断实例"); Container container=frame.getContentPane(); //获取容器 final JProgressBar progressBar=new JProgressBar(); //创建进度条 progressBar.setStringPainted(true); //设置进度条数字显示 frame.add(progressBar,BorderLayout.CENTER); //进度条居中 frame.setSize(580,460); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); thread=new Thread(new Runnable() { int count=0; @Override public void run() { while(true) { progressBar.setValue(++count); //设置进度条的值 try { Thread.sleep(1000); }catch(InterruptedException e) { System.out.println("当前线程被中断"); break; } } } }); thread.start(); thread.interrupt(); } public static void main(String[] args) { new InterruptedSwing(); } }
        • 运行结果：
    • 4. 线程的礼让：Thread类中提供了一种礼让方法，使用yield()方法表示，它只是给当前正处于运行状态的线程一个提醒，告知它可以将资源礼让给其他线程，但这仅是一种暗示，没有任何一种机制保证当前线程会将资源礼让。 yield()方法使具有同样优先级的线程有进入可执行状态的机会，当当前线程放弃执行权时会再度回到就绪状态。对于支持多任务的操作系统来说，不需要调用yield()方法，因为操作系统会为线程自动分配CPU时间片来执行。
    • 5. 线程的优先级：每个线程都具有各自的优先级，线程的优先级可以表明在程序中该线程的重要性，如果有很多线程处于就绪状态，系统会根据优先级来决定首先使哪个线程进入运行状态。但这并不意味着低优先级的线程得不到运行，而只是它运行的概率比较小，如垃圾回收线程的优先级就较低。 Thread类中包含的成员变量代表了线程的某些优先级，如Thread.MIN_PRIORITY（常数1）、Thread.MAX_PRIORITY（常数10）、Thread.NORM_PRIORITY（常数5）。其中每个线程的优先级都在Thread.MIN_PRIORITY~Thread.MAX_PRIORITY之间，在默认情况下其优先级都是Thread.NORM_PRIORITY。每个新产生的线程都继承了父线程的优先级。 在多任务操作系统中，每个线程都会得到一小段CPU时间片运行，在时间结束时，将轮换另一个线程进入运行状态，这时系统会选择与当前线程优先级相同的线程予以运行。系统始终选择就绪状态下优先级较高的线程进入运行状态。
      • 实例代码： package com.THREAD; import javax.swing.*; import java.awt.*; public class PriorityTest extends JFrame { private Thread thread1; private Thread thread2; private Thread thread3; private Thread thread4; public PriorityTest() { JFrame frame=new JFrame("线程优先级实例"); Container container=frame.getContentPane(); frame.setLayout(new GridLayout(4,1)); //设置布局 final JProgressBar progressBar1=new JProgressBar(); final JProgressBar progressBar2=new JProgressBar(); final JProgressBar progressBar3=new JProgressBar(); final JProgressBar progressBar4=new JProgressBar(); //创建4个进度条 progressBar1.setStringPainted(true); progressBar2.setStringPainted(true); progressBar3.setStringPainted(true); progressBar4.setStringPainted(true); //设置进度条数字显示 frame.add(progressBar1); frame.add(progressBar2); frame.add(progressBar3); frame.add(progressBar4); //将进度条添加到容器中 thread1=new Thread(new MyThread(progressBar1)); thread2=new Thread(new MyThread(progressBar2)); thread3=new Thread(new MyThread(progressBar3)); thread4=new Thread(new MyThread(progressBar4)); //实例化线程类 setPriority("thread1",Thread.MAX_PRIORITY,thread1); setPriority("thread2", Thread.NORM_PRIORITY,thread2); setPriority("thread3",3,thread3); setPriority("thread4",Thread.MIN_PRIORITY,thread4); //调用构造方法 frame.setSize(800,688); frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); frame.setVisible(true); } public static void setPriority(String threadName,int priority,Thread t) { //定义一个设置线程名称，优先级的方法 t.setName(threadName); //设置线程名称 t.setPriority(priority); //设置线程优先级 t.start(); //启动线程 } private final class MyThread implements Runnable { //定义一个实现Runnable接口的类 private final JProgressBar bar; int count=0; private MyThread(JProgressBar bar) { this.bar=bar; } public void run() { while(true) { bar.setValue(++count); try{ Thread.sleep(1000); }catch(InterruptedException e) { System.out.println("线程已中断"); break; } } } } public static void main(String[] args) { new PriorityTest(); } }
        • 在本实例中定义了4个线程，这4个线程用于设置4个进度条的进度。这里定义了setPriority()方法，该方法设置了每个线程的优先级和名称等。虽然在运行结果中这4个进度条好像是在一起滚动，但如果仔细观察还是可以看出细微差别，可以看到第一个进度条总是最先变化。由于thread1线程和thread2线程优先级最高，所以系统首先处理这两个线程，然后是thread3和thread4这两个线程。
        • 运行结果：
• 五、 线程同步
  • 在单线程程序中，每次只能做一件事情，后面的事情需要等待前面的事情完成后才可以进行，但是如果使用多线程程序，就会发生两个线程抢占资源的问题，如两个人同时说话、两个人同时过同一个独木桥等。所以在多线程编程中需要防止这些资源访问的冲突。Java提供了线程同步的机制来防止资源访问的冲突。
• 六、 线程安全
  • 实际开发中，使用多线程程序的情况很多，如银行排号系统、火车站售票系统等。这种多线程的程序通常会发生问题，以火车站售票系统为例，在代码中判断当前票数是否大于0，如果大于0则执行将该票出售给乘客的功能，但当两个线程同时访问这段代码时（假如这时只剩下一张票），第一个线程将票售出，与此同时第二个线程也已经执行完成判断是否有票的操作，并得出票数大于0的结论，于是它也执行售出操作，这样就会产生负数。所以在编写多线程程序时，应该考虑到线程安全问题。实质上线程安全问题来源于两个线程同时存取单一对象的数据。
    • 实例代码： package com.THREAD; public class ThreadSafeTest implements Runnable{ int num=10; //设置当前票数 public void run() { while(true) { if (num>0) { try { Thread.sleep(1000); }catch(InterruptedException e) { e.printStackTrace(); } System.out.println("售票成功,剩余票数:"+num--); } } } public static void main(String[] args) { ThreadSafeTest t=new ThreadSafeTest(); //实例化对象 Thread t1=new Thread(t); //将该类对象实例化出4个线程 Thread t2=new Thread(t); Thread t3=new Thread(t); Thread t4=new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); //启动线程 } }
      • 运行结果：
        • 从图中可以看出，最后打印售剩下的票为负值，这样就出现了问题。这是由于同时创建了4个线程，这4个线程执行run()方法，在num变量为1时，线程1、线程2、线程3、线程4都对num变量有存储功能，当线程1执行run()方法时，还没有来得及做递减操作，就指定它调用sleep()方法进入就绪状态，这时线程2、线程3和线程4都进入了run()方法，发现num变量依然大于0，但此时线程1休眠时间已到，将num变量值递减，同时线程2、线程3、线程4也都对num变量进行递减操作，从而产生了负值。
• 七、 线程同步机制
  • 基本上所有解决多线程资源冲突问题的方法都是采用给定时间只允许一个线程访问共享资源，这时就需要给共享资源上一道锁。这就好比一个人上洗手间时，他进入洗手间后会将门锁上，出来时再将锁打开，然后其他人才可以进入。
    • 1. 同步块:在Java中提供了同步机制，可以有效地防止资源冲突。同步机制使用synchronized关键字
      • 实例代码： package com.THREAD; public class ThreadSafeTest implements Runnable{ int num=10; //设置当前票数 public void run() { while (true) { synchronized ("") { //使用线程同步 if (num > 0) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("售票成功,剩余票数:" + num--); } } } } public static void main(String[] args) { ThreadSafeTest t=new ThreadSafeTest(); //实例化对象 Thread t1=new Thread(t); //将该类对象实例化出4个线程 Thread t2=new Thread(t); Thread t3=new Thread(t); Thread t4=new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); //启动线程 } }
        • • 从图中可以看出，打印到最后票数没有出现负数，这是因为将资源放置在了同步块中。这个同步块也被称为临界区，它使用synchronized关键字建立，其语法如下： synchronized(Object){ } 通常将共享资源的操作放置在synchronized定义的区域内，这样当其他线程也获取到这个锁时，必须等待锁被释放时才能进入该区域。Object为任意一个对象，每个对象都存在一个标志位，并具有两个值，分别为0和1。一个线程运行到同步块时首先检查该对象的标志位，如果为0状态，表明此同步块中存在其他线程在运行。这时该线程处于就绪状态，直到处于同步块中的线程执行完同步块中的代码为止。这时该对象的标志位被设置为1，该线程才能执行同步块中的代码，并将Object对象的标志位设置为0，防止其他线程执行同步块中的代码。
    • 2. 同步方法：同步方法就是在方法前面修饰synchronized关键字的方法，其语法如下 synchronized void f(){} 当某个对象调用了同步方法时，该对象上的其他同步方法必须等待该同步方法执行完毕后才能被执行。必须将每个能访问共享资源的方法修饰为synchronized，否则就会出错。
      • 实例代码： package com.THREAD; public class ThreadSafeTest implements Runnable{ int num=10; //设置当前票数 synchronized void doit() { if (num > 0) { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("售票成功,剩余票数:" + num--); } } public void run() { while(true){ doit(); //调用同步方法 } } public static void main(String[] args) { ThreadSafeTest t=new ThreadSafeTest(); //实例化对象 Thread t1=new Thread(t); //将该类对象实例化出4个线程 Thread t2=new Thread(t); Thread t3=new Thread(t); Thread t4=new Thread(t); t1.start(); t2.start(); t3.start(); t4.start(); //启动线程 } }