java学习笔记多线程学习总结（上）

一、进程的简述

1、进程：
是一个正在执行中的程序。每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。Java中主线程要运行的代码在main中存储，自定义线程存在run中。
2、线程：
就是进程中的一个独立的控制单元，线程在控制着进程的执行。一个进程中至少有一个线程。
Java jvm启动时会有一个进程java.exe。该进程中至少有一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中该线程称之为主线程。
3、扩展：
其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回事机制的线程。
4、多线程存在的意义：
使程序的部分产生同时运行效果，提高效率。

二、创建进程

1、如何在自定义的代码中，自定义一个线程呢？

继承Thread类，重写run()方法。创建步骤：
1、定义类继承Thread

2、复写Thread类中的run方法（目的是：将自定义代码存储在run方法，让线程运行）
3、调用线程的start方法，该方法有2个作用：启动线程、调用run方法。
eg：class Demo extends Thread // 定义一个线程类
{
public void run() // 重写run方法
{
for(int x=0;x<60;x++) // 循环的目的是让线程多运行一会。
System.out.println(“demo run--”+x);
}
}
class ThreadDemo
{
public static void main(String[] args)
{
Demo d = new Demo(); // 建立好一个对象其实就是实例创建一个线程
d.start(); // 线程启动
for(int x=0;x<60;x++)
System.out.println(“Hello world!..”+x); // 主线程
}
}
2、实现Runnable接口，覆写run方法。详细步骤：

1、定义类实现Runable接口。
2、覆盖Runable接口中的run方法。将线程要运行的代码放在该run方法中。
3、通过Thread类建立线程对象。
4、将Runable接口的子类对象作为实际参数传递给Thread类的构造函数（为什么要将Runable 接口的子类对象传 递给Thread的构造函数）因为，自定义的run方法所属的对象是Runable接口的子类对象，所以要让线程去指
定指定对象的run方法。就必须明确该run方法所属对象。
5、调用Thread类的start方法，开启线程，并调用Runable接口子类的run方法。

eg：classTicket implements Runnable // (extendsThread) // 定义类实现Runnable接口用于创建线程

{

private void run() // 实现run方法

{

while(true)

{

if(ticket>0) // 票数大于0时出票

{ System.out.println(Thread.currentThread().getName()+”…sale:”+tick--); }

}

}

}

class TicketDemo

{

public static void main(String[] args)

{

Ticket t = new Ticket();

Thread t1 = new Thread(t); // 创建两个个线程，参数是实现接口的类对象。

Thread t2 = new Thread(t2);

t1.start(); // 启动线程

t2.start();

}

}

3、实现方式和继承方式的区别？
1、实现方式的好处，避免了单继承的局限性。在定义线程时，建立使用实现方式。
2、继承Thread：线程代码存放Thread子类run方法中，实现Runable，线程代码存在接口的子类的run方法。

注：发现程序运行结果每一次都不同，以newi多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。明确一点，在某一个时刻，只能有一个程序在运行（多核除外）cpu做着快速的切换，以达到看上去是同时运行的效果。我们可以形象地把多线程的运行认为在互相抢夺cpu的执行权。这就是多线程的一个特性：随机性，谁抢到谁执行。至于执行多长时间，Cpu说的算。

三、线程的四种常见状态：
1、New（新创建）
2、Runnable（可运行）
3、Blocked（被阻塞）
4、Waiting（等待）
5、Timed waiting（计时等待）
6、Terminated（被终止）

四、线程的方法介绍

1、staticThread currentThread(); 返回当前正在执行的线程对象。静态方法
2、getName(); 获取线程名称。
3、设置线程名称：setName或者构造函数。调用父类构造super(name);

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

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

Java对于多线程的安全问题提供了专业的解决方式：同步代码块。
同步代码块的格式：Synchronized（对象）{ 需要被同步的代码 }
说明：那些语句要操作共享数据，那些语句就需要同步。
eg：class Ticket implements Runnable
{
private int tick = 100;
Object obj = new Object();
public void run()
{
while(true)
{
Synchronized(obj)
{
if(tick>0)
{
try{Thread.sleep(10);} // 停止10秒看效果
catch(Exception e)
{ }
System.out.println(Thread.currentThread().getName()+”..sale:”+tick--);
}
}
}
}
}
同步代码块的对象参数相当于锁，持有锁的线程可以在同步中执行，没有持有锁的线程即便获取cpu的执行权，也进不去，因为没有获取锁。
同步的前提：
1、必须要有2个或2个以上的线程。
2、多个（必须）多个线程使用同一个锁（必须保证同步中只能有一个线程在运行）
同步代码块的好处：解决了多线程的安全问题。
同步代码块的弊端：多个线程需要判断锁，较为消耗资源。

如何找出同步问题：
1、明确哪些代码是多线程运行代码（run中代码及run中调用代码）
2、明确共享数据。
3、明确多线程运行代码中哪些语句是操作共享数据的。
同步有2种表现形式：同步代码块和同步函数。

同步函数封装的定要是需要同步的语句（例如while循环不能放）

同步代码块封装代码，唯一的区别是他带着同步性，若让函数具备同步性，就可以。

六、同步锁

同步函数用的是哪一个锁？
函数需要被对象调用，那么函数都有一个所属对象引用就是this，所以同步函数的使用锁是this。证明实例如下：

class Ticket implements Runnable

{

private int tick = 1000;

Booleanflag = true;

public void run()

{

if(flag)

{

while(true)

{

Synchronized(this)

{

if(tick>0)

{

try{ Thread.sleep(10); }catch(Exception e){ }

}

else

while(true)

(this.)show();

}

System.out.println(Thread.currentThread().getName()+”…sale:”+tick--);

}

}

}

}

class ThisLockDemo

{

public static void main(String[] args)

{

Ticket t = new Ticket();

Thread t1 = new Thread(t);

Thread t2 = new Thread(t);

t1.start(); // 一线程开始用同步代码块

t.flag = false; // 二线程开始用同步函数

t2.start();

}

}

如果同步函数被静态修饰后，使用的锁是什么呢？
通过验证发现不是this，因为静态方法中也不可以定义this。
静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。就是类名.class。该对象的类型是class（可以通过getClass()方法获取）。静态的同步方法使用的锁是该方法所在类的字节码文件对象，类名.class。且此对象在内存中是唯一的。

七、死锁
死锁，同步嵌套同步。在编写程序过程中要尽量避免死索。

创建一个死锁程序的例子：

class Test implements Runnable

{

private Boolean flag;

Test(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

{

Synchronized(MyLock.lockb)

{

System.out.println(“else lockb”);

Synchronized(MyLock.locka)

{

System.out.println(“elselocka”);

}

}

}

}

}

class MyLock

{

static Object locka = new Object();

static Object lockb = new Object();

}

class DeadLockTest

{

public static void main(String[] args)

{

Thread t1 = new Thread(new Test(true)); Thread t2 = new Thread(new Test(false));

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

}

}