java多线程及安全问题

进程：是一个正在执行中的程序。

每一个进程执行都有一个执行顺序，该顺序是一个执行路径，或者叫一个控制单元。

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

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

通过对api的查找，java已经提供了对线程这类事物的描述，就是Thread类

1.创建线程的第一种方式：继承Thread类。

步骤：

1.定义类继承Thread类

2.复写Thread类中的run方法。

目的：将自定义代码存储在run方法，让线程运行。

3.调用线程的start方法，启动线程，调用run方法。

class Demo extends Thread

{

//run()方法为线程的主要方法，所要依赖线程运行的代码都要在这个函数里运行

public void run()

{

//多线程运行的代码块

}

}

main(String args[])

{

//创建Thread子类对象的同时，线程也被创建了。

Demo d = new Demo();

//用start方法开启线程，执行Demo类中的run方法。

d.start();

//如果调用run方法，就仅仅是调用了Demo类中run方法，并未启动新的线程

d.run();

}

各种方法的作用：

sleep(time) 使线程冻结一段时间，时间到后线程自动运行；

wait() 使线程暂停，等待notify() 方法唤醒后线程方可继续运行；

stop() 结束当前线程。

例子：多个窗口同时卖票。

利用第一种创建线程的方式实现卖票

class Ticket extends Thread{

//利用静态成员变量共享票数。但是静态变量比较耗费资源。

private static int tick = 100;

public void run(){

while(true){

if(tick>0){

System.out.println(Thread.currentThread().getName()+": "+tick--);

}

}

}

}

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();

}

2.创建线程的第二种方式：实现Runable接口

步骤：

1.定义类实现Runnable接口

2.覆盖Runnable接口中的run方法。

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

3.通过Thread类建立线程对象。

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

为什么要将Runnable接口的子类对象传递给Thread的构造函数。

因为，自定义的run方法所属的对象时Runnable节后的子类对象。

所以要让线程去指定指定对象的run方法，就必须明确该run方法所属对象。

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

售票例子：

class Ticket implements Runnable{

private int tick = 100;

public void run(){

while(true){

if(tick>0){

System.out.println(Thread.currentThread().getName()+": "+tick--);

}

}

}

}

public static void main(String args[]){

//与上面的售票相比，实现票数共享是通过只创建一个Runnable子类对象来实现

//将此对象通过多个线程来运行，以达到多线程效果。

Ticket t1 = new Ticket();

new Thread(t1).start();

new Thread(t2).start();

new Thread(t3).start();

new Thread(t4).start();

}

实现方式和继承方式有什么区别呢？（面试常考）

现方式好处：避免了单继承的局限性。

在定义线程时，建议使用实现方式。

java机制只允许继承一个父类，但是可以实现多个接口，有的时候一个子类需要继承父类

但同时又需要被多线程执行时，就不可能再继续用继承Thread类的方式实现多线程了，

只能通过实现Runnable 接口来实现多线程。

多线程安全问题：

问题的原因：

当多条哦语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完。

另一个线程参与进来执行，导致共享数据的错误。

解决办法：

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

同步代码块。

synchronized(对象){

//需要被同步的代码

}

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

没有持有锁的线程即使获取cpu执行权，也进不去，因为没有获取锁。

同步的前提：

1.必须要有两个或者两个以上的线程。

2.必须是多个线程使用同一个锁

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

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

如何找问题：

1.明确哪些代码是多线程运行代码。

2.明确共享数据。

3.明确多线程运行代码中哪些语句是操作共享数据的。

同步有两种形式：

1.同步代码块 ： synchronized(对象){

//需要被同步的代码

}

2.同步函数 ： 把synchronized作为修饰符放在函数上，此函数就具备了同步的特性。

同步函数用得到是哪一个锁呢？

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

所以同步函数使用的锁是this。利用如下代码验证：

private int tick = 100;

public void run(){

if(flag){

while(true){

synchronized(this/*此处未为验证精髓*/){

//同步代码块

if(tick>0){

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

System.out.println(Thread.currentThread().getName()+"..code.."+tick--)

}

}

}

}else

while(true)

show();

}

public synchronized void show(){

//需要同步的内容

if(tick>0){

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

System.out.println(Thread.currentThread().getName()+"..show.."+tick--)

}

}

//通过观察输出票数是否安全便可知道，同步函数的锁是否是this

public void main(String args[]){

new Thread(对象).run();

//让线程等待10ms，以便确认0线程已进入代码块

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

flag=false;

new Thread(对象).run();

}

静态同步函数，使用的锁是什么呢？

通过验证，不是this，因为静态方法中也不可以定义this。

静态进内存时，内存中没有本类对象，但是一定有该类对应的字节码文件对象。

类名.class 该对象的类型是Class ，所使用的锁是该方法所在类的字节码文件对象。

(重点)单例设计模式：

饿汉式：

class Single{

//先创建对象，需要的时候直接调用

private static final Single s = new Single();

//将构造函数私有化，禁止外界的访问。

private Single(){}

public static Single getInstance(){

return s;

}

}

懒汉式：

class Single{

private static Single s = null;

private Single(){}

public static Single getInstance(){

//双重判断，提高懒汉式的效率，一次创建对象以后，就不再需要判断锁

if(s==null){

//多线程多次判断锁，影响效率

synchronized(Single.class){

//如果不存在对象，才要创建对象，称延迟加载

if(s==null)

s=new Single();

}

}

return s;

}

}

死锁：例子：

public void run(){

if(flag){

while(true){

synchronized(MyLock.locka){

Syste.out.printlnt("if locka");

synchronized(MyLock.lockb){

Syste.out.printlnt("if lockb");

}

}

}

}else{

while(true){

synchronized(MyLock.lockb){

Syste.out.printlnt("else lockb");

synchronized(MyLock.locka){

Syste.out.printlnt("else locka");

}

}

}

}

}

class MyLock {

public static Object locka=new Object();

public static Object lockb=new Object();

}