(18)Java学习笔记——多线程01

Thread类

如何创建一个线程：

创建线程方式一：继承Thread类

1/定义一个类继承Thread

2/覆盖Threa类中run方法

3/直接创建Thread的子类对象创建线程

4/调用atart方法开启线程并调用线程的任务run方法执行

class  ThreadDemo01{public static void main(String[] args) {Demo p = new Demo("小鱼儿");//创建Thread的子类对象创建线程Demo p1 = new Demo("xiexiecm");p.start();//开启线程，调用run方法p1.start();}}class Demo extends Thread//创建一个Thread的子类继承Thread{private String name;Demo(String name){this.name = name;}public void run()//创建一个run方法，覆写Thread中的run方法{for (int x=0;x<100 ;x++ ){System.out.println(name+"....x="+x);}}}

创建线程的目的是为了开启一条执行路径，去运行指定的代码和其他代码实现同时运行。

而运行的指定代码就是这个执行路径的任务。

JVM创建的主线程的任务都定义在主函数中。

Thread类用于描述线程，线程是需要任务的，所以Thread类也对任务的描述。

这个任务就通过Thread类中的run方法来体现，也就是说，run方法就是封装自定义线程运行任务的函数。

run方法中定义的就是线程要运行的任务代码。

开启线程是为了运行指定代码。所以只有继承Thread类，并覆写run方法，将运行的代码定义在run方法中即可。

线程方法

可以通过Thread的getName获取线程的名称 Thread-数字

线程的状态

创建线程方式二：实现Runnable接口

实现步骤：

1/定义类实现Runnable接口

2/覆盖接口中的run方法，将线程的任务代码封装到run方法中

3/通过Thread类创建线程对象，并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。

（因为线程的任务都封装在Runnable接口子类对象的run方法中，所以要在线程对象创建时就必须明确要运行的任务。）

4/调用线程对象的start方法开启线程。

Thread(Runnable target)构造函数，target参数——其run方法被调用的对象。

class ThreadDemo02 {public static void main(String[] args) {Demo d = new Demo();//Thread t1 = new Thread(d);//线程对象一建立，必须有任务。用Runnable接口的构造函数传递任务对象（Runnable target）Thread t2 = new Thread(d);t1.start();t2.start();}}class Demo implements Runnable//定义类实现Runnable接口{public void run()//Runnable接口的唯一一个方法run，覆盖{show();}public void show(){for (int x=0;x<20 ;x++ ){System.out.println(Thread.currentThread().getName()+"...."+x);}}}

Runnable的出现仅仅是将线程的任务进行了对象封装。就是用来封装线程对象的。类型是Runnable类型

实现Runnable接口和继承Thread类的区别：（实现Runnable接口的好处）

1/将线程的任务从线程的子类中分离出来，进行了单独的封装。按照面向对象的思想将任务封装成对象。

2/避免了java单继承的局限性。

范例：

/*需求：四个窗口同时卖100张卖票*/class ThreadTest001 {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);Thread t4 = new Thread(t);t1.start();t2.start();t3.start();t4.start();/*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 implements Runnable//线程任务封装{private int num = 100;public void run(){while(true){if (num>0){System.out.println(Thread.currentThread().getName()+"....sale...."+num--);}}}}

线程安全问题产生的原因：

1/多个线程在操作共享的数据

2/操作共享数据的线程代码有多条

当一个线程在执行操作共享数据的多条代码过程中，其他线程参与了运算，就会导致相称安全问题的产生。

解决思路：

就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程是不可以参与运算的。

必须要当前县城吧这些代码都执行完毕后，其它线程才可以参与运算。

用synchronized同步代码块解决这个问题，

格式：

synchronized(对象） //此对象——理解成一个同步锁。类似开关，第一个线程进来后设置了切换，告诉了第二个线程不能进来。——同步锁

//（理解成火车上的卫生间  有人/无人）

{

需要被同步的代码；

}

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

同步的弊端：相对降低了效率，因为同步外的线程都会判断同步锁。

同步的前提：同步中必须有多个线程并使用同一个锁。

同步的表现形式：

1/同步代码块

class Bank{private int sum;private Object obj = new Object();public void add(int num){synchronized(obj)//同步代码块 （obj）同步锁{sum = sum + sum;System.out.println("sum="+sum);}

2/同步函数

同步函数用的锁！！同步函数使用的锁是this，静态方法的锁不是this

class Bank{private int sum;private Object obj = new Object();public synchronized void add(int num)//同步函数{sum = sum + sum;System.out.println("sum="+sum);}}

同步函数和同步代码块的区别：

1/同步函数的锁是固定的this

2/同步代码块的锁是任意的对象

静态同步函数使用的锁就是该函数所属的字节码文件对象，可以用getclass方法获取，也可以用当前  类名 . class表示

————————————————————————————————————————

死锁

常见情景之一：同步的嵌套

class Test implements Runnable{private boolean flag;Test(boolean flag){this.flag = flag;}public void run(){if (flag){synchronized(MyLock.locka)//线程一拿了a锁{System.out.println("iflocka....");synchronized(MyLock.lockb)//线程一想拿b锁，但是被线程二拿了{System.out.println("iflockb....");}}}else{synchronized(MyLock.lockb)//线程二拿了b锁，{System.out.println("elselockb.....");synchronized(MyLock.locka)//线程二想拿b锁，但是被线程一拿了{System.out.println("elselocka....");}}}}}class MyLock{public static final Object locka = new Object();public static final Object lockb = new Object();}class DeadLockTest {public static void main(String[] args) {Test a = new Test(true);Test b = new Test(false);Thread t1 = new Thread(a);//建立两个线程Thread t2 = new Thread(b);t1.start();t2.start();}}