Java多线程

Java多线程

---

• 在主线程中调用其他线程
• start方法与run方法的区别
• 实现多线程的两种方法
• 实现同步的几种方法
• synchronize关键字

在主线程中调用其他线程

public class Test1 {
 public static void main(String[] args) {
      Thread2 thread=new Thread2();
      thread.start();
      for(int i=0;i<50;i++){
          System.out.println("Main"+i);
      }
  }
}
  class Thread2 extends Thread {
      @Override
    public void run() {
        for(int i=0;i<50;i++){
            System.out.println("Thread"+i);
        }
    }
  }

输出结果

Main0
Thread0
Thread1
Thread2
Thread3
Thread4
Thread5
Thread6
Thread7
Thread8
Thread9
Main1
Thread10
Main2
Thread11
Main3
Thread12
Thread13
Thread14
Thread15
Thread16
Main4
Thread17
Thread18
Thread19
Main5
Thread20
Thread21
Main6
Thread22
Main7
Thread23
Main8
Thread24
Main9
Thread25
Main10
Thread26
Main11
Thread27
Main12
Thread28
Main13
Thread29
Main14
Thread30
Main15
Thread31
Main16
Thread32
Main17
Thread33
Main18
Thread34
Main19
Thread35
Main20
Thread36
Main21
Thread37
Main22
Thread38
Main23
Thread39
Main24
Thread40
Main25
Thread41
Main26
Thread42
Main27
Thread43
Main28
Thread44
Main29
Main30
Thread45
Thread46
Thread47
Thread48
Thread49
Main31
Main32
Main33
Main34
Main35
Main36
Main37
Main38
Main39
Main40
Main41
Main42
Main43
Main44
Main45
Main46
Main47
Main48
Main49

首先对多线程有一个直观的了解，在单线程的程序中程序入口为main方法，在这个方法中程序依次序执行，而对于上述程序在main方法中（main方法相当于一个线程）创建Thread2实例，并调用该实例的start方法，创建了一个新的线程，同时这个线程的创建并不影响主线程的运行，这就造成了主线程与创建的线程同时运行的状态（如果是单线程的话，应该等Thread2对象的start方法运行结束后，才运行下面的循环输出，如果thread2调用run方法则会出现这种情况）

start方法与run方法的区别

创建一个线程，并启动该线程的时候需要调用的是start方法，调用start方法线程会进入到就绪状态，调用start方法启动一个新的线程去执行代码，而调用run方法相当于一个普通的方法调用，不会有新的线程启动，因此上述代码中如果是调用thread2.run（）则会这行完该方法才会顺序执行之后的代码。
总而言之，启动一个新的线程需要start（）方法。

例如：

public class ThreadDemo2 {  
    public static void main(String[] args) {  
        Thread5 t1=new Thread5();  
        Thread6 t2=new Thread6();  
        t1.run();  
        t2.start();  
        for(int i=0;i<100;i++){  
            System.out.println("主进程执行："+i);  
        }  
    }  
}  

class Thread5 extends Thread{  
    @Override  
    public void run() {  
        for(int i=0;i<100;i++){  
            System.out.println("Thread5执行："+i);  
        }  
    }  
}  

class Thread6 extends Thread{  
    @Override  
    public void run() {  
        for(int i=0;i<100;i++){  
            System.out.println("Thread6执行："+i);  
        }  
    }  
} 

运行结果会是t1执行完之后，t2和main方法交替执行。

实现多线程的两种方法

java中实现多线程一种方法是集成Thread类 另一种方法是实现runnable接口

public class Ticket extends Thread{

    private int ticket;
    public Ticket() {
        this.ticket=100;
    }
   @Override

       public void run(){
                  while(true){
                     if(this.ticket > 0){
                        System.out.println(Thread.currentThread().getName() +
                          "is saling ticket" + ticket--);
                     }else{
                       break;
                    }
                 }
              }



  public static void main(String[] args) {
    Ticket station=new Ticket();
    station.start();
    station.start();
} 

上述写法是有问题的，因为对于一个线程对象 station，只能够启动一个线程 即使是调用多次start方法 依旧是启动了一个线程，并且会报错

那么将代码改为如下：

  public static void main(String[] args) {
    Ticket station=new Ticket();
    station.start();
    Ticket station2=new Ticket();
    station2.start();
} 

这时 构造多个线程对象，并分别调用各自的start方法，这是又会出现一个问题 即 两个线程之间的数据是不共享的，每个station对象都会输出从100到1，不会出现这个线程将第90张票卖出 第二个线程就不会卖出第90张票的情况

如果此时改用Runnable接口实现的话：

public class Ticket implements Runnable{

 private int ticket;
 public Ticket() {
    this.ticket=100;
}


@Override
public void run() {
    while(this.ticket>0){
        System.out.println(Thread.currentThread()+":"+this.ticket);
        this.ticket--;
    }

} 

public static void main(String[] args) {
    Runnable station=new Ticket();
    Thread a=new Thread(station);
    a.start();
    Thread b=new Thread(station);
    b.start();
}

这个时候每个线程都是调用的同一个Ticket对象的run方法，访问的是同一个对象实例

因此Runable与Thread相比的好处是：
1.解决了Java中单继承带来的局限性
2.代码能够对多个线程共享 ，例如上述中 线程a和线程b共享同一个station对象实例，多个线程能够操作相同的数据。

实现同步的几种方法

1.使用synchronized 方法

Synchronize关键字