Java 多线程 （概述）

1，多线程的定义

       如果一个程序有多条执行路径，则被称为多线程。       

       进程：正在执行的程序。

       线程：程序的执行路径。执行单元。

       单线程：如果一个应用程序只有一条执行路径，则称为单线程。

       多线程：如果一个应用程序有多条执行路径，则称为多线程。

2，实现的两种方案

           1，继承Thread类

            1，自定义类继承Thread类

            2，重写run()方法

            3，写测试类是创建自定义类对象

            4，调用start()方法

//继承Thread类
class MyThread extends thread{
    @override
    public void run(){
        for(int i=0;i<100;i++){
            System.out.println(getName()+"-"+x);
        }
    }
}

class Test{
    public static void main(String[] args){
        MyThread m1=new MyThread();
        MyThread m2=new MyThread();

        m1.setName("zhangshan");
        m2.setName("lishi"); 

        m1.start();
        m2.start();
    }
}

         2，实现Runnable接口

            1，自定义类实现Runnable接口

            2，重写run()方法

            3，写测试类创建自定义类对象

            4，调用start()方法

//实现Runnable接口
class MyRunnable implements Runnable{
    @override
    public void run(){
        for(int i=0;i<100;i++){
           System.out.pritnln(Thread.currentThread().getName()+"-"+i);
        }
    }
}

class Test{
    public static void main(String[] args){
        MyRunnable m=new MyRunnable();
        
        Thread t1=new Thread(m,"zhangshan");
        Thread t2=new Thread(m,"lishi");

         t1.start();
         t2.start();
    }
}

        注意：既然有了第一种实现方案，为什么还要第二种？

                  因为类只能单继承，而接口可以多实现。

      

3，Lock

         1，Jdk5新特性，它把什么时候获取锁什么时候释放锁给明确了。

       2，死锁：

               同步中，多个线程使用多把锁相互等待

       3，线程间的通信

               不同种类的线程针对共享的数据进行操作

       4，需要掌握的方法：

                           优先级

                                 public final void setPriority(int newPriority)
                                      public final int getPriority()

                                 线程默认的优先级是：5

                                 线程优先级的范围是：1-10

                                注意：线程优先级，一般情况下，效果不大。

                                      在次数特别多的情况下，线程优先级高的对象可能会比线程优先的先获取执行权。

                           加入

                                 public final void join()

                                 等待该线程的终止，。

                               注意：加入线程必须是该线程开启之后做的动作。

                           暂停

                                 public static void yield()

                                   暂停当前执行的线程对象，当执行其它线程。

                                   只能在一定程度上保证程序的和谐运行，如果想要达到效果，需要采用等待唤醒机制。

                           守护线程

                                    public final void setDaemon(boolean on)

4，注意事项

             1，线程安全问题是怎么产生的？怎么解决？

                   先作判断：

                       怎么产生的？

                          a，程序是否为多线程

                          b，是否有共享数据

                          c，是否有多条语句对共享数据进行操作

                  解决方案：

                        把c步骤进行管理。

                              1，同步代码块

                                        格式：

                                               synchronized(对象)｛

                                                       需要被锁的代码

                                              ｝

                                      注意:对象可以是任意对象，但同步的对象必须一致。

                              2，同步方法

                                        把synchronized添加到方法声明上。

                                              注意：此时同步的是this对象。                

             2，静态方法的锁是谁？

                       当前类的字节码文件对象。

             3，run()与start()的区别？

                    run()仅仅是普通的调用

                     start()做了两件事：启动线程，调用run()

             4，sleep()与wait()的区别？

                  sleep():表示睡眠，必须指定睡眠时间，不释放锁。

                   wait():表示等待，可以不指定睡眠时间，必须释放锁。       

    

5，案例

//自定义类
class Ticket implements Runnable{
    private static int ticket=100;
    private int x=0;
    @override
    public void run(){
        while(true){
            if(x%2==0){
                synchronized(Ticket.class){
                         if(ticket>0){
                             System.out.println(Thread.currentThread().getNameI()+"正在出售"+(ticket--));
                         }
                }
            }else{
                sendTicket();
            }
        }
    }
    private static synchronized void sendTicket(){
        if(ticket>0){
            System.out.println(Thread.currentThread().getName()+"正在出售"+(ticket--));
        }
    } 
}

class test{
    public static void main(String[] args){
         Ticket t=new Ticket();
      
         Thread t1=new Thread(t,"第一窗口");
         Thread t2=new Thread(t,"第二窗口");
         Thread t3=new Thread(t,"第三窗口");

         t1.start();
         t2.start();
         t3.start();  
    }
}