【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 }
20 
21 public class Thread01{
22     public static void main(String[] args){
23         ThreadTest1 t1 = new ThreadTest1();
24         ThreadTest1 t2 = new ThreadTest1();
25         Thread t3 = new Thread(new ThreadTest2());　　//注意
26         Thread t4 = new Thread(new ThreadTest2());
27         
28         //start() 启动线程
29         t1.start();
30         t2.start();
31         t3.start();
32         t4.start();
33     }
34 }

 1 class ThreadTest2 implements Runnable{
 2     private int count=20;    //共享资源
 3     public void run(){
 4         String threadName = Thread.currentThread().getName();
 5         while(count>0){
 6             System.out.println("ThreadTest2 "+threadName+" 售出 "+count+" 号票");
 7             count--;
 8         }
 9     }
10 }
11 
12 public class ThreadDemo2{
13     public static void main(String[] args){
14         ThreadTest2 t2 = new ThreadTest2();
15         (new Thread(t2,"窗口1")).start();
16         (new Thread(t2,"窗口2")).start();
17         (new Thread(t2,"窗口3")).start();
18         (new Thread(t2,"窗口4")).start();    
19     }
20 }

ThreadTest2 窗口1 售出 20 号票
ThreadTest2 窗口1 售出 19 号票
ThreadTest2 窗口3 售出 20 号票
ThreadTest2 窗口2 售出 20 号票
ThreadTest2 窗口3 售出 17 号票
ThreadTest2 窗口1 售出 18 号票
ThreadTest2 窗口1 售出 14 号票
ThreadTest2 窗口4 售出 19 号票
ThreadTest2 窗口1 售出 13 号票
ThreadTest2 窗口3 售出 15 号票
ThreadTest2 窗口3 售出 10 号票
ThreadTest2 窗口2 售出 16 号票
ThreadTest2 窗口2 售出 8 号票
ThreadTest2 窗口3 售出 9 号票
ThreadTest2 窗口1 售出 11 号票
ThreadTest2 窗口4 售出 12 号票
ThreadTest2 窗口1 售出 5 号票
ThreadTest2 窗口3 售出 6 号票
ThreadTest2 窗口2 售出 7 号票
ThreadTest2 窗口3 售出 2 号票
ThreadTest2 窗口1 售出 3 号票
ThreadTest2 窗口4 售出 4 号票
ThreadTest2 窗口2 售出 1 号票

在Java里面，同步锁的概念就是这样的。任何一个Object Reference都可以作为同步锁。我们可以把Object Reference理解为对象在内存分配系统中的内存地址。
    
解决方案：
1）同步代码块
    synchronized(类或对象)
    {
        需要同步的代码段
    }
2）同步函数
    （非static的情况）
    public synchronized void fun()
    {
        代码段
    }
    等价于
    public void fun()
    {
        synchronized(this)
        {
            代码段
        }
    }
    调用此同步函数的对象作为此同步函数的同步锁。
    
    (static的情况)
    public static synchronized void fun()
    {
        代码段
    }
    静态变量或静态方法加载到内存中时，内存中没有本类对象，但一定有了该类对应的
    字节码文件（类名.class)，该对象的类型是class。静态同步函数使用的同步锁是所在类
    的字节码文件。        

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

//饿汉式
class Singleton{
    private static final Singleton singleInstance = new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return singleInstance;
    }
}

//懒汉式
class Singleton{
    private static Singleton singleInstance =null;
    private Singleton(){}
    public static synchronized Singleton getInstance(){
        if(singleInstance==null){
            singleInstance = new Singleton();
        }
        return singleInstance;
    }
}

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

void setPriority(priority)
int getPriority()