java笔记15 多线程1-CSDN博客

本文链接：https://blog.csdn.net/thoris/article/details/46508769

1. 多线程概述

1.1 进程：正在执行中的程序

每一个进程执行都有一个执行顺序，概述徐是一个执行路劲个，或者叫一个控制单元

进程可以同时开启，但是cpu只是在快速地切换（所以卡住的时候就是切换不过来了）

一个进程当中可以有多个路径，就是线程。

1.2 线程:就是进程中的一个独立的控制单元。

线程在控制着进程的执行。

1.3 Jvm启动的时候会有一个进程java.exe

该进程中至少有一个线程负责java程序的执行。

而这个线程运行代码存在于main函数中，该线程称之为主线程。

Jvm不是单线程，同时还进行垃圾回收。

1.4 多线程的好处：解决了多部分代码同时运行的问题。
多线程的弊端：线程太多，会导致效率的降低。

多个应用程序同时执行都是CPU在做着快速的切换完成的。这个切换是随机的。CPU的切换是需要花费时间的，从而导致了效率的降低。

public class FinalizeTest
{
         public static void main(String[] args)
         {
                   new Demo1();
        new Demo1();
        System. gc();
        new Demo1();
        System.out.println("Hello World!");
         }
}
class Demo1 extends Object
{
    public void finalize()
    {
         System.out.println("demo ok");
    }
}

结果：

Hello World!

demo ok

分析：

先打印HelloWorld！再打印demo ok，是因为两条线程是分别执行的。

只打印一个demo ok，是因为在垃圾回收器还没回收第二个Demo对象的时候，JVM就已经结束了。

System类的gc方法告诉垃圾回收器调用finalize方法，但不一定立即执行。

2. 线程的状态

1、被创建 new Thread

2、运行状态 start()

3、冻结：睡眠和等待

sleep(time)：在时间到了就恢复,释放执行权，不释放锁。

wait(): 释放执行权、释放锁。需要唤醒notify()

4、消亡：stop()。run方法结束。

5、阻塞：等待执行权或者指令（比如io流的输入）

3. 创建多线程的第一种方式——继承Thread类

1、定义类继承Thread

2、复写Thread类中的run方法

目的：将自定义的代码存储在run方法中

3、调用线程的start方法，该方法有两个作用

启动线程

调用run方法。

4、因为多个线程都获取cpu的执行权，cpu执行到谁，谁就运行

在某一时刻，只能有一个程序运行（多核除外）cpu在作者快速的切换，已达到看上去是同时运行的效果

5、多线程具有随机性，谁抢到谁执行，至于执行多长，cpu说了算。

6、为甚要覆盖run方法

Thread类用于描述线程。该类就定义了一个功能,用于存储线程要运行的代码，该存储功能就是run方法, 也就是说 Thread类中的run方法，用于存储线程要运行的代码。

public class H_02ThreadDemo
{
                            public  static void main(String[]args)
                            {
                                               Demo d=new Demo();//创建新的控制单元
                                               d.start();//由新线程控制
                                               //d.run(); //仅仅是对象调用方法，仍由主线程执行。
                                               for(inti=0;i<300;i++)//主线程控制
                                                        System.out.println("hello----"+i);
                            }
}
 
class Demo extends Thread
{
                            public void run()
                            {
                                     for(inti=0;i<300;i++)
                                               System.out.println("run----"+i);
                            }
}

结果是 run1~299，hello1~299

在单线程程序中，只有上一句代码执行完，下一句代码才有执行的机会。创建线程的目的就是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行，而运行的指定代码就是这个执行路径的任务。

4. 线程名称

线程有自己默认的名称

Thread-编号从0开始

通过static Thread currentThread():获取当前线程对象

获取线程名称：getName();

设置线程名称：setName或者构造函数

public class H_04ThreadTest
{
                   public static void main(String[] args)
                   {
                                     Test t1=new Test("one");//通过构造方法修改线程名称
                                     Test t2=new Test("two");                                 
                                     t1.setName("线程1");//通过setName方法修改线程名称
                                     t1.start();
                                     t2.start();
                                     System.out.println(t1.getName());
                                     System.out.println(t2.getName());
                                     for(inti=0;i<3;i++)
                                     {
                                               System.out.println("main run..."+i);
                                     }
                   }
}
 
class Test extends Thread
{
                            private Stringname;
                            Test(String name)
                            {
                                     super(name);//通过父类构造函数设置线程名称
                            }       
                            public void run()
                            {
                                     for(inti=0;i<3;i++)
                                     {
                                               System.out.println(Thread.currentThread().getName()+" run..."+i);
                                     }
                            }
}

结果

线程1
two
线程1 run...0
two run...0
线程1 run...1
main run...0
线程1 run...2
two run...1
two run...2
main run...1
main run...2

5. 卖票问题

/*
 买票小程序
 多个窗口同时买票
  */
public class H_07ThreadTicket
{
         public static void main(String[] args)
         {
                            Ticket t1=new Ticket();
                            Ticket t2=new Ticket();
                            Ticket t3=new Ticket();
                            Ticket t4=new Ticket();
                            t1.start();
                            t2.start();//会卖出同样的票
                            t3.start();
                            t4.start();                           
         }
 
}
class Ticket extends Thread//多窗口买票
{
                   private int ticket=100;//加入定义成静态，可以解决（因为只有一个参数），但是这样权限太大
                   public void run()
                   {
                            while(true)
                            {
                                     if(ticket>0)
                                     {                                             System.out.println(Thread.currentThread().getName()+"sale:"+ticket--);
                                     }
                            }
                   }
}

上述程序有一个问题，t1、t2、t3、t4分别建立了四个线程，都会卖出1-100的票，这是不符合现实的。解决这个问题的关键就要用到创建线程的另外一种方法。

6. 创建线程的第二种方法——实现Runnable接口

1、定义类实现Runnable接口

2、覆盖Runnable接口中的run方法

将线程要运行的代码存放在该run方法中。

3、通过Thread类建立线程对象

4、将Runnable接口的子类对象作为实际参数传递给Thread类的构造函数

自定义的run方法所属的对象是Runnable接口的子类对象

所以要在线程对象创建时就必须明确要运行的任务。

5、调用Thread类的start方法开启线程并调用Runnable接口子类的run方法。

6、实现Runnable接口的好处：
将线程的任务从线程的子类中分离出来，进行了单独的封装，按照面向对象的思想将任务封装成对象。
避免了Java单继承的局限性。所以，创建线程的第二种方式较为常用。

卖票程序

public class H_08RunnableDemo
{
         public static void main(String[] args)
         {
                   Tick t=new Tick();//这个时候对象只有一个，所以只有100张票
                   Thread t1=new Thread(t);//创建了一个线程 new Thread(new Tick())
                   Thread t2=new Thread(t);
                   Thread t3=new Thread(t);
                   Thread t4=new Thread(t);
                   t1.start();
                   t2.start();
                   t3.start();
                   t4.start();
         }
}
class Ticket extends Thread//多窗口买票
{
         private int ticket=100;
                   public void run()
                   {
                            while(true)
                            {
                                     if(ticket>0)
                                     {                                             System.out.println(Thread.currentThread().getName()+"sale:"+ticket--);
                                     }
                            }
                   }
}

票可以正常卖完，但是出现了0、-1之类的票，这就涉及到了线程的安全问题。

7. 线程安全问题产生的原因

1、当多条语句在操作同一个线程共享数据时，一个县曾对多条语句只执行了一部分，还没有执行完，另一个线程参与进来执行，导致共享数据的错误。

2、解决办法：

对多条操作共享数据的语句，只能让一个线程都执行完，再执行过程中，其他线程不可以参与运行。

3、Java对于多线程的安全问题提供了专业的解决方式——使用同步代码块

同步代码块

Synchronized（对象）//对象就是一个锁

{

需要被同步的代码块

}

8. 同步

对象如同锁，只有锁的线程可以在同步中执行

没有持有锁的线程及时获取cpu的执行权，也进不去。

同步的前提

1、必须有两个或者两个以上的线程

2、必须是多个线程使用同一个锁（）

3、必须保证同步中只能有一个线程在运行

好处：解决了多线程的安全问题

弊端：多个线程都需要判断锁，较为消耗资源。

同步有两种方式

一种是同步代码块

一种是同步函数（在函数前加synchronized）

修改后的买票程序

public class H_08RunnableDemo
{
         public static void main(String[] args)
         {
                   Tick t=new Tick();//这个时候对象只有一个，所以只有100张票
                   Thread t1=new Thread(t);//创建了一个线程 new Thread(new Tick())
                   Thread t2=new Thread(t);
                   Thread t3=new Thread(t);
                   Thread t4=new Thread(t);
                   t1.start();
                   t2.start();
                   t3.start();
                   t4.start();
         }
}
class Tick implements Runnable
{
                   private int ticket=100;
                   Object obj=new Object();
                   public void run()
                   {
                            while(true)
                            {
                                     synchronized(obj)//上锁，有线程进入，锁上，线程退出，开锁
                                               {       
                                                        if(ticket>0)
                                                        {
                                                                 try{
                                                                 Thread.sleep(5);//sleep是静态方法，本身抛出中断异常，故需要处理
                                                                 //处理只能使用try catch
                                                                           }
                                                                 catch(InterruptedExceptione)
                                                                           {
                                                                           }                                                                System.out.println(Thread.currentThread().getName()+"sale:"+ticket--);
                                                        }
                                               }
                                                        if(ticket<=0)
                                                                 return; //不return会死循环
                                     }
                   }
}

正常售完，无负数票。

9. 函数的锁

9.1 同步函数用的是哪一个锁？

函数需要被对象调用，那么函数都有一个所属对象的引用，就是this

所以同步函数的锁是this

9.2 静态同步函数

静态方法中不可能有this，所以锁不是this。

应该是一个比静态方法还要早存在于内存的才可以。

这个对象就是该类对应的class字节码文件，这是在类加载到内存就会产生的，而且是一个唯一的对象，可以作为静态函数的锁。

10. 死锁示例

死锁是指同步中嵌套同步，但锁不同。因为不同线程互相等待对方的锁，造成程序无法运行的情况。

示例1：

public class H_DeadLock
{
         public static void main(String[] args)
         {
                   Tik t=new Tik();
                   Thread t1=new Thread(t);
                   Thread t2=new Thread(t);
                   t1.start();
                   try
                   {
                   Thread.currentThread().sleep(10);
                   }
                   catch(Exceptione){}
                   t.flag=false;
                   t2.start();
         }
}
class Tik implements Runnable
{
                   private int ticket=1000;
                   Object obj=new Object();
                   booleanflag =true;
                   public void run()
                   {
                            if (flag)
                            {
                                               while(true)
                                                        {
                                                        synchronized(obj)//锁是obj
                                                                 {
                                                                           show();//锁是this
                                                                 }
                                                        if(ticket<=0)
                                                                 return;
                                                        }
                            }
                            else
                                     while(true)
                                                        show();
                   }
                   public synchronized void show()// this锁
                   {
                            synchronized(obj)//锁是obj
                            {
                                     if(ticket>0)
                                               {
                                                        try
                                                                 {
                                                                           Thread.sleep(10);
                                                                 }
                                                        catch(InterruptedExceptione)        {}                                                     System.out.println(Thread.currentThread().getName()+"sale:"+ticket--);
                                               }
                                     }
                   }
}

示例2

public class H_15DeadLockTest
{
         public static void main(String[] args)
         {
                   Thread t1=new Thread(new T(true));
                   Thread t2=new Thread(new T(false));
                   t1.start();
                   t2.start();
         }
}
class  T  implements Runnable
{
         private boolean flag;
         T(boolean flag)
         {
                   this.flag=flag;
         }
         public void run()
         {
                   if (flag)
                   {                          
                            while(true)
                            {
                                     synchronized(Mylock.locka)
                                     {
                                               System.out.println("if  locka");
                                               synchronized(Mylock.lockb)
                                               {
                                                        System.out.println("if lockb");
                                               }
                                     }
                            }
                   }
                   else
                   {
                            while(true)
                            {
                                               synchronized(Mylock.lockb)
                                               {
                                                        System.out.println("else lockb");
                                                        synchronized(Mylock.locka)
                                                        {
                                                                 System.out.println("else locka");
                                                        }
                                               }
                            }
                   }
         }
}
 
class Mylock
{
          static Object locka=new Object();//静态对象唯一
          static Object lockb=new Object();
}

结果：

else lockb

if locka