【Java基础总结】多线程

 1 //第一种：继承Thread类，重写run()方法
 2 class ThreadTest1 extends Thread{
 3     public void run(){
 4         String threadName = Thread.currentThread().getName();
 5         for(int i=0;i<10;i++){
 6             System.out.println("ThreadTest1 "+threadName+" running ... "+i);
 7         }
 8     }
 9 }
10 
11 //第二种：实现Runnable接口，重写run()方法
12 class ThreadTest2 implements Runnable{
13     public void run(){
14         String threadName = Thread.currentThread().getName();
15         for(int i=0;i<10;i++){
16             System.out.println("ThreadTest2 "+threadName+" running ... "+i);
17         }
18     }
19 }

public class Demo1{    
    public static void main(String[] args){
        ThreadTest1 t1 = new ThreadTest1();
        ThreadTest1 t2 = new ThreadTest1();
        Thread t3 = new Thread(new ThreadTest2());
        Thread t4 = new Thread(new ThreadTest2());
        t1.start();
        t2.start();
        t3.start();
        t4.start();
    }
}

Thread.currentThread().getName()  获得当前线程的名称
threadObj.setName()  设置线程名称

class ThreadTest4 implements Runnable{
    private int ticket=20;
    public void run(){
        String threadName = Thread.currentThread().getName();
        while(ticket>0){
            System.out.println("ThreadTest4 "+threadName+" 售出 "+ticket+" 号票");
            ticket--;
        }
    }
}

     (new Thread(new ThreadTest4(), "窗口a")).start();
     (new Thread(new ThreadTest4(), "窗口b")).start();
     (new Thread(new ThreadTest4(), "窗口c")).start();
     (new Thread(new ThreadTest4(), "窗口d")).start();

    ThreadTest4 t2 = new ThreadTest4();
    (new Thread(t2,"窗口1")).start();
    (new Thread(t2,"窗口2")).start();
    (new Thread(t2,"窗口3")).start();
    (new Thread(t2,"窗口4")).start();

 1 class ThreadTest5 implements Runnable{
 2     private int ticket=20;
 3     public void run(){
 4         while(ticket>0){        
 5             String threadName = Thread.currentThread().getName();
 6             //同步代码块（越小越好）
 7             synchronized(this){
 8                 if(ticket>0){
 9                     System.out.println(threadName + " sales ticket "+ticket);
10                     ticket--;
11                 }
12             }
13         }
14     }
15 }
16 
17 public class Demo3{
18     public static void main(String[] args){
19         ThreadTest5 t = new ThreadTest5();
20         (new Thread(t, "窗口A")).start();
21         (new Thread(t, "窗口B")).start();
22         (new Thread(t, "窗口C")).start();
23         (new Thread(t, "窗口D")).start();
24     }
25 }

synchronized(类或对象){
    //需要同步的代码段
}

public synchronized void fun(){
    //代码段
}

public void fun() {
    synchronized(this) {
        //代码段
    }
} 

public static synchronized void fun() {
    //代码段
}

 2     class Repository{
 3         private int count=0;        //当前仓库存放商品数量
 4         private int capacity=5;        //仓库容量
 5         private String goodsName;    //商品名称
 6         public Repository(String goodsName){
 7             this.goodsName = goodsName;
 8         }
 9         public void store(String threadName){
10             synchronized(this){
11                 while(this.count>=this.capacity){
12                     System.out.println("[" + threadName + "]仓库已达到最大容量 " + this.capacity + " 个 !!");
13                     try{this.wait();}
14                     catch(Exception e){}
15                 }
16                 this.count++;
17                 System.out.println("[" + threadName + "]仓库增加了一个"+this.goodsName+"，现有"+this.goodsName+"["+this.count+"] 个");
18                 this.notifyAll();
19             }
20         }
21         public void fetch(String threadName){
22             synchronized(this){
23                 while(this.count<1){
24                     System.out.println("[" + threadName + "]仓库没有"+this.goodsName+"!!");
25                     try{
26                         this.wait();
27                     }catch(Exception e){
28                         
29                     }
30                 }
31                 this.count--;
32                 System.out.println("[" + threadName + "]仓库减少了一个"+this.goodsName+"，现有"+this.goodsName+"["+this.count+"] 个");
33                 this.notifyAll();
34             }
35         }
36     }
37     //生产者
38     class Producter implements Runnable{
39         private Repository repository ;
40         public Producter(Repository repository){
41             this.repository = repository;
42         }
43         public void run(){
44             String threadName = Thread.currentThread().getName();
45             while(true){
46                 try{ 
47                     //sleep 2秒模拟生产过程
48                     Thread.sleep(1000); 
49                 }catch(Exception e){
50                     
51                 }
52                 //把生产的商品存放到仓库
53                 repository.store(threadName);
54             }
55         }
56     }
57     //消费者
58     class Consumer implements Runnable{
59         private Repository repository ;
60         public Consumer(Repository repository){
61             this.repository = repository;
62         }
63         public void run(){
64             String threadName = Thread.currentThread().getName();
65             while(true){
66                 //将商品从仓库取出来
67                 repository.fetch(threadName);
68                 try{ 
69                     //sleep 4秒模拟消费过程
70                     Thread.sleep(2000); 
71                 }catch(Exception e){
72                     
73                 }
74             }    
75         }
76     }
77     public class Thread06{
78         public static void main(String[] args){
79             Repository repository = new Repository("馒头");
80             
81             Producter pro1 = new Producter(repository);
82             Consumer con1 = new Consumer(repository);
83             //生产者和消费者各2个
84             (new Thread(pro1, "生产者A")).start();    
85             (new Thread(pro1, "生产者B")).start();
86             (new Thread(con1, "消费者1")).start();
87             (new Thread(con1, "消费者2")).start();
88         }
89     }

 1 [消费者1]仓库没有馒头!!
 2 [消费者2]仓库没有馒头!!
 3 [生产者A]仓库增加了一个馒头，现有馒头[1] 个
 4 [消费者2]仓库减少了一个馒头，现有馒头[0] 个
 5 [消费者1]仓库没有馒头!!
 6 [生产者B]仓库增加了一个馒头，现有馒头[1] 个
 7 [消费者1]仓库减少了一个馒头，现有馒头[0] 个
 8 [生产者A]仓库增加了一个馒头，现有馒头[1] 个
 9 [生产者B]仓库增加了一个馒头，现有馒头[2] 个
10 [生产者A]仓库增加了一个馒头，现有馒头[3] 个
11 [消费者2]仓库减少了一个馒头，现有馒头[2] 个
12 [生产者B]仓库增加了一个馒头，现有馒头[3] 个
13 [消费者1]仓库减少了一个馒头，现有馒头[2] 个
14 [生产者A]仓库增加了一个馒头，现有馒头[3] 个
15 [生产者B]仓库增加了一个馒头，现有馒头[4] 个
16 [消费者2]仓库减少了一个馒头，现有馒头[3] 个
17 [生产者A]仓库增加了一个馒头，现有馒头[4] 个
18 [消费者1]仓库减少了一个馒头，现有馒头[3] 个
19 [生产者B]仓库增加了一个馒头，现有馒头[4] 个
20 [生产者A]仓库增加了一个馒头，现有馒头[5] 个
21 [生产者B]仓库已达到最大容量 5 个 !!
22 [消费者2]仓库减少了一个馒头，现有馒头[4] 个
23 [生产者B]仓库增加了一个馒头，现有馒头[5] 个
24 [生产者A]仓库已达到最大容量 5 个 !!
25 [消费者1]仓库减少了一个馒头，现有馒头[4] 个
26 [生产者A]仓库增加了一个馒头，现有馒头[5] 个
27 [生产者B]仓库已达到最大容量 5 个 !!
28 [生产者A]仓库已达到最大容量 5 个 !!

1)线程“消费者1”调用repositoy.fetch()方法去仓库取馒头。进入synchronized块，刚一执行while语句，结果 this.count<1 为真，直接就wait()进入等待队列，最后释放了锁
（就绪队列[消费者2，生产者A，生产者B]，等待队列[消费者1]）
2)线程“消费者2”同“消费者1”的遭遇是相同的（对此，我们深表同情）
（就绪队列[生产者A，生产者B]， 等待队列[消费者1，消费者2]）
3)线程“生产者A”生产完商品后，调用repository.store()方法把商品存到了仓库中。在store方法里，使用notifyAll方法唤醒了所有在沉睡wait的线程，最后释放了锁
（就绪队列[生产者A，生产者B，消费者1，消费者2]，等待队列[]）
4)线程“消费者2”从上次wait的地方开始执行（从哪里跌倒，就从哪里爬起来）。同样是while语句，但这次 this.count<1 不为真了，于是乎顺利脱坑，接着执行 this.count--，把仓库仅有的一个馒头给拿走了，走之前还不忘大喊一句“仓库减少了一个馒头，现有馒头[0] 个”。同样是notifyAll方法唤醒所有沉睡wait的线程，释放锁
（就绪队列[生产者A，生产者B，消费者1，消费者2]，等待队列[]）
5)线程“消费者1”辛辛苦苦抢到了锁，终于能执行syschronized块代码了。和“消费者2”一样，也是从上次wait的地方接着执行，也是while语句，但不同的是 this.count<1 为真，线程“生产者A”生产存放到仓库的仅有的一个馒头被“消费者2”给吃了，可以想象此时的“消费者1”心里是万念俱灰的。啥也别说了，接着沉睡wait吧。（释放了锁）
(就绪队列[生产者A，生产者B，消费者2],等待队列[消费者1])

**** 在接下来的几十个回合中，时而生产者线程夺得仓库锁，称霸武林，时而消费者线程夺得，笑傲江湖，仓库商品也是时增时减，但总体上还是生产者线程抢到的次数多，因为生产者够快，当消费者还在花2秒钟费劲的消化时，生产者早就1秒生产完毕，参与仓库锁的再次争夺了，可见“天下武功，唯快不破” *****

“仓库里没有馒头为什么不通知我？”，线程“消费者2”不满“消费者1”对仓库情况的隐瞒不报，“你要是早告诉我，我也就不用争抢仓库锁，抢到了也没用，里面根本就没有馒头，去了也是wait”。（第1、2步）
“你还有脸说我，你把生产者A生产存放在仓库仅有的一个馒头吃了，你明知道仓库再也没有馒头了，也不告诉我，还让我傻了吧唧抢到仓库锁，去了也白搭”。“消费者1”反驳道，它同样也很委屈。（第4、5步）
“管我什么事，抢仓库锁的有不只你一个，我也去抢了，白费了劲，还没抢到....”，线程“消费者2”道。

“要是仓库没有馒头的时侯，只唤醒那帮生产者就好了”，线程“消费者1”和“消费者2”异口同声的说道。

interrupt()        //停止线程
isInterrupt()     //判断线程是否停止

public static void main(String[] args){    
    Thread t3 = new Thread(test2, "线程t3");
    t3.start();
    t3.join();　　//主线程就此陷入等待，直到t3线程结束。
}

void setPriority(priority)    //设置线程优先级
int getPriority()            //获取线程优先级