黑马程序员——多线程知识总结1

-------
android培训、java培训、期待与您交流！ ----------
多线程算是Java中比较重要的一个部分了，下面把个人觉得的一些重要内容和大家分享下~~

概述

进程：正在执行中的程序

线程：进程中一个负责程序执行的控制单元（执行路径）。

P.S.

1、一个进程中可以有多个执行路径，称之为多线程。

2、一个进程中至少要有一个线程。

多线程的好处：解决了多部分代码同时运行的问题。

多线程的弊端：线程太多，会导致效率的降低。

其实，多个应用程序同时执行都是CPU在做着快速的切换完成的。这个切换是随机的。CPU的切换是需要花

费时间的，从而导致了效率的降低。————>多线程的实质(⊙o⊙)哦。

在单线程程序中，只有上一句代码执行完，下一句代码才有执行的机会。

如何定义一个线程？

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

1.定义一个类继承Thread类。

2.覆盖Thread类中的run方法。

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

4.调用start方法开启线程并调用线程的任务run方法执行。

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

P.S.

继承Thread类的类对象调用start方法开启了线程，并执行线程的run方法；

而直接调用run方法，仅仅是对象调用方法，没有新线程开启；

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

1.定义类实现Runnable接口。

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

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

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

方式二更为常用~~（Java中是单继承，使用方式二避免了Java单继承的局限性。）

其实下面才是重点——多线程的安全性

问题的原因：

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

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

解决办法：

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

在java中，用同步代码块就可以解决这个问题。

同步代码块的格式：

synchronized(对象){

需要被同步的代码;其实就是操作共享数据的语句

}

对象如同锁。持有锁的线程可以在同步中执行。没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。

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

同步的弊端：当线程相当多时，因为每个线程都会去判断同步上的锁，无形中会降低程序的运行效率。

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

当synchronized出现在函数声明上，函数就具备了同步性（同步函数）

利用同步代码块解决安全问题案例：

/*
需求：
银行有一个金库。
有两个储户分别存300元，每次存100，存3次。

如何找问题：
1，明确哪些代码是多线程运行代码。
2，明确共享数据。
3，明确多线程运行代码中哪些语句是操作共享数据的。

*/

class Bank
{
private int sum;//金库金额
public void add(int n)
{
synchronized(this)
{
sum = sum + n;
System.out.println("sum="+sum);
}
}
}

class ChuHu implements Runnable
{
private Bank b = new Bank();
public void run()//储户向金库存钱

{
for(int x=0; x<3; x++)
{
b.add(100);
}
}
}

class  BankDemo
{
public static void main(String[] args)
{
ChuHu c = new ChuHu();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}

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

1.同步函数的锁是固定的this。

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

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

总结完各种同步后，提醒各位小心死锁（同步中嵌套同步，但个同步中锁不一样）

上个死锁的例子，小心避免啊

class Test implements Runnable
{
private boolean flag;//标记位，好让下面出现死锁
Test(boolean flag)
{
this.flag = flag;//两线程创建时传入不同标记
}

public void run()
{
if(flag)//标记位true的到这来
{
while(true)
{
synchronized(MyLock.locka)//持有locka
{
System.out.println(Thread.currentThread().getName()+"...if locka ");
synchronized(MyLock.lockb)//标记位false的线程持有lockb时，这里就停住进不去了
{
System.out.println(Thread.currentThread().getName()+"..if lockb");
}
}
}
}
else//标记位false的
{
while(true)
{
synchronized(MyLock.lockb)//持有lockb
{
System.out.println(Thread.currentThread().getName()+"..else lockb");
synchronized(MyLock.locka)//当上面的持有locka这里就停这了
{
System.out.println(Thread.currentThread().getName()+".....else locka");
}
}
}
}
}
}

//封装两个锁方便使用
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();
}
}

额，先到这里，下回在更