java 多线程学习笔记

这篇文章主要是个人的学习笔记，是以例子来驱动的，加深自己对多线程的理解。

---

一：实现多线程的两种方法

1.继承Thread

class MyThread1 extends Thread{
    public void run(){
        System.out.println("这是自定义的线程");
    }
}

通过继承Thread，然后重写Thread中的run方法，把自己要实现的方法写在run()中

 class ThreadTest1{
     public static void main(String[] args){
         MyThread1 mythread = new MyThread1();
         mythread.start();
     }
 }    

2.实现Runnable接口

 class MyThread implements Runnable{
     public void run(){
         System.out.println("这是自定义的实现Runnable接口的线程");
     }
 }

实现Runnable接口，然后实现它的方法run

class ThreadTest1{
    public static void main(String[] args){
        MyThread mythread = new MyThread();
        Thread thread = new Thread(mythread);
        thread.start();
    }
}

把mythread传到Thread的构造方法中，然后就生成了一个线程。

二：线程的安全性问题

 class MyThread implements Runnable{
      int i = 100;
      public void run(){
          while(true){
              System.out.print(Thread.currentThread().getName()+i+“ ”);
              Thread.yield();
              i--;
              if(i<0){
                  break;
              }
         }
     }
 }

class ThreadTest{
    public static void main(String[] args){
        MyThread mythread = new MyThread();
        Thread thread = new Thread(mythread);
        Thread thread2 = new Thread(mythread);
        thread.setName("线程A");
        thread2.setName("线程B");
        thread.start();
        thread2.start();
    }
}

ThreadTest的main运行结果：

线程A10 线程B10 线程A9 线程B8 线程A7 线程B6 线程A5 线程B4 线程A3 线程B2 线程B1 线程A0

这结果是不是很奇怪，为什么有线程A10 线程B10 。要是这是一个火车售票系统，那么不是卖个两个人同一个火车票了么？

也许这个例子过于简单，看不出什么，可以参考：http://www.blogjava.net/tscfengkui/archive/2010/11/10/337709.html?opt=admin

原因主要是线程A运行run方法，运行到System.out.println()，但是还没有运行到i--，可是这是线程B抢占到了资源，那么线程B开始运行，然后线程B又运行到了System.out.println()，然后线程A或者B中有一个运行i--.然后A再运行println()。

解决办法就是在线程运行run使用资源的时候交给他一把锁，等它把事情做完后在把锁给另一个要用这个资源的线程。这样就不会出现上述情况。 实现这个锁的功能就需要用到synchronized这个关键字。

synchronized这个关键字有两种用法1、放方法名前形成同步方法；2、放在块前构成同步块。

方法1：在方法名前形成同步方法

class MyThread implements Runnable{
    int i = 10;
    public void run(){
         /* for(int i = 0; i <100; i++){
             //获得当前正在运行线程的名字
            System.out.println(Thread.currentThread().getName()+i);
        }  */
        this.meA();
        }
    public synchronized void meA(){
        while(true){
            System.out.print(Thread.currentThread().getName()+i+" ");
            Thread.yield();
            i--;
            if(i<=0){
                break;
            }
        }
    }
}

运行结果

线程A10 线程A9 线程A8 线程A7 线程A6 线程A5 线程A4 线程A3 线程A2 线程A1 线程B0

方法二：放在块前构成同步块

比如上面例子中，只要在while中加入一个方法块

 while(true){
        synchronized(this){
           System.out.print(Thread.currentThread().getName()+i+" ");
           Thread.yield();
           i--;
           if(i<0){
               break;
           }
      }
 }

那么实现的结果和上面是一样的。

---

这是我今天学习多线程的结果，多线程很深奥，越学越觉得好多还不懂，只能每天进步一点。