java笔记15 多线程1

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

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