黑马程序员-Java编程知识总结多线程

------- android培训、java培训、期待与您交流！ ----------

-Java编程知识点总结。

一.多线程。

1. 什么是进程：进程是正在运行的程序。2.运行中的电脑看上去可以同时执行多个程序其实CPU同一时刻只能运行一个程序，之所以看上去是在同时运行，是因为CPU在不停的切换执行。每一个进程执行都一个执行顺序，该顺序是一个执行路径或者叫一个执行单元。

2. 什么是线程：线程就是进程中的一个独立的单元，线程在控制进程的执行。

3. jvm启动的时候会有一个进程java.exe。该进程至少有一个线程负责java程序的执行，而且这个线程运行的代码存在于main方法中。该线程称作为主线程。

二.自定义线程。

Java已经提供了对线程这类食物的描述。Thread类。

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

1，定义类继承Thread。

2，复写Thread类中的run方法。目的：将自定义代码存储在run 方法。让线程运行。

3，调用线程的start方法，该方法两个作用：启动线程，调用run方法。

class Demoextends Thread

{

public void run ()

{

for(int i = 0;i<=60;i++)

{

System.out.println(i);

}

}

}

classThreadDmo

{

public static void main(String[] args)

{

Demo d = new Demo();//创建继承自Thread类的子类对象。

d.start();//start作用是开启线程，并调用run()方法。

for(int x=0; x<60; x++)

System.out.println("HelloWorld!--"+x);

}}

练习一：

创建两个线程，和主线程交替运行。线程都有自己默认的名称，Thread-编号的形式，编号是从0开始。Thread-0;

获取当前线程对象：static Thread currentThread（）；

设置线程的名称：setName();

class Testextends Thread

{

//private String name;

Test(String name)

{

//this.name = name;

super(name);//调用父构造函数，将对象名称传给父。

}

public void run()

{

for(int x=0; x<60; x++)

//获取当前线程的对象获取当前线程对象的名称。

//该方法写于run方法中，即写于当前线程中使用。

//那个线程运行当前的run，就获得谁的对象t1，或t2。

{System.out.println((Thread.currentThread()==this)+"..."+this.getName()+"run..."+x);

}

}

}

class ThreadTest

{

public static void main(String[] args)

{

Test t1 = new Test("one---");

Test t2 = new Test("two+++");

t1.start();

t2.start();

for(int x=0; x<60; x++)

{

System.out.println("main....."+x);

}

}

}

2.多线程状态图：

3.（必须掌握）练习二：售票。

class Tickets extends Thread

{privateint ticket = 100;

Tickets(String name)

{

super(name);//必须会使用，1.使用构造函数2.调用父构造3.传对象的名称。

}

publicvoid run()

{

while (ticket>0)

{

ticket-=1;

System.out.println(Thread.currentThread()+"sales"+ticket+this.getName());

}

}

}

class TicketDemo

{

publicstatic void main(String[] args)

{

Ticketst1 = new Tickets("线程1");

Ticketst2 = new Tickets("线程2");

Ticketst3 = new Tickets("线程3");

Ticketst4 = new Tickets("线程4");

t1.start();

t2.start();

t3.start();

t4.start();

}

}

2.创建线程的第二种方式。

1.实现Runnable接口。

2.重写run（）方法。

3.（*）通过Thread类创建线程对象。

4.使用Thread类创建线程对象。将实现自Runnable接口的子类对象作为参数传递给Thread类的构造方法。因为自定义对象的run方法是Runnable接口的抽象方法run方法是子类的方法。而真正能使run方法运行的是Thread类所以要让线程运行run就得把Runnable的子类对象传递给Thread。

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

6．实现方式和继承方式的区别：使用Runnable接口可以实现多继承，即当继承了Thread类，子类就不能再继承其他类。当实现自Runnable接口，子类即创建了线程，又可以再继承其它的类。

5多线程安全问题

多线程安全问题出现的原因：

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

如下所示：

class Tickets extends Thread

{privateint ticket = 100;//该数据是4个线程共享的数据

Tickets(String name)

{

super(name);

}

//run方法是4个线程共同执行的方法。存在于每个线程中，不是共享的。X定义在函数中属于局部是非共享，ticket是定义在类中的是共享的

publicvoid run() //throws RuntimeException子类只能抛父类的子集，父类没有抛。所以不能抛出。

{intx；

while (ticket>0)

{ try

{

Thread.sleep(50);//throwsInterruptedException该方法在使用时自动抛出异常，所以要处理。

//有可能出现以下情况1.2.3.4线程。当ticket
= 1时，1线程获取执行权，打印1；然后自减为0。

//这时2线程获得了执行权，又打印了一次0，自减为-1.这时3线程执行，又打印了-1.这些线程就没有进行条件判断，在这里输出了错值。

System.out.println(this.getName()+"sales"+ticket--);

}

catch (Exception e)

{

}

}

}

}

class TicketDemo

{

publicstatic void main(String[] args)

{

Ticketst1 = new Tickets("线程1");

Ticketst2 = new Tickets("线程2");

Ticketst3 = new Tickets("线程3");

Ticketst4 = new Tickets("线程4");

t1.start();

t2.start();

t3.start();

t4.start();

}

1.（*）解决办法对多条操作共享数据的语句只让一个线程执行完，其他线程都不可以参与。使用同步代码块。

synchronized(对象)

{

需要被同步的代码

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

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

把上个例子的代码修改为安全的代码：

Object obj = new Object();

public void run()

{

//锁就是对象。当线程t1.t2执行到这时，

// 1.假如t1获得了锁，锁标0->1；

4.t2获得了执行权，t2进入，执行输出语句。

Synchronized(obj)
锁标（0）禁止（1）进入

{//2.t1线程进入后锁标1->0;t2进不来。

while (ticket>0)

{

try

{

Thread.sleep(50);//线程会在这儿冻结，

当时间到后，转入到阻塞状态等cpu执行权。

System.out.println(this.getName()+"sales"+ticket--);

}

catch (Exception e)

{

}

}

//3.当t1执行完后退出0->1;t1跳出锁。

}

}

在锁标处的执行情况：

1.假如t1持有了锁，锁标0->1；

2.t1线程进入后锁标1->0;t2进不来。

3.当t1执行完后退出0->1;t1跳出锁。

4.此时可进入,t2获得了执行权，t2进入，执行输出语句。

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

同步的前提：

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

2，必须是多个线程使用同一个锁。（同一个对象）

3.必须保证同步中只能有一个线程在运行。

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

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

1. （*）同步函数:使函数具有同步性。在函数的返回类型前加上synchronized.所以到这里同步方法有两种：

1.同步函数：使用synchronized作为修饰放在返回类型的前边。 2.同步代码块，使用synchroized(对象){}.的方式实现同步。

如何找问题：

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

2，明确共享数据。

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

class Bank

{

privateint sum;//sum是共享数据所以要把操作共享数据的语句封装为同步语句。

//Objectobj = new Object();

publicsynchronized void add(int n)

{

//synchronized(obj)

//{

sum= sum + n;

try{Thread.sleep(10);}catch(Exceptione){}

System.out.println("sum="+sum);

//}

}

}

class Cus implements Runnable

{

privateBank b = new Bank();

publicvoid run()

{

for(intx=0; x<3; x++)

{

b.add(100);//调用了包含共享数据的方法。

}

}

}

class BankDemo

{

publicstatic void main(String[] args)

{

Cusc = new Cus();

Threadt1 = new Thread(c);

Threadt2 = new Thread(c);

t1.start();

t2.start();

}

}

练习：使用同步函数的方式重写售票的例子。

2. 同步函数的锁。

同步函数用的是哪一个锁呢？函数需要被对象调用。那么函数都有一个所属对象引用。就是this。所以同步函数使用的锁是this。

下面的实例来验证上面的结论：

通过该程序进行验证。使用两个线程来买票。一个线程在同步代码块中。一个线程在同步函数中。

都在执行买票动作。

class Ticket implements Runnable

{

private int tick = 100;

Objectobj = new Object();

booleanflag = true;

public void run()

{

if(flag)

{

while(true)

{//当锁使用obj时，线程会出现打印错误的票数，表明线程出现了不同步的情况，当时用this时，打印正确。表明this时同步函数的锁。

synchronized(this)

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exceptione){}

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

}

}

}

}

else

while(true)

show();

}

publicsynchronized void show()//this

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exceptione){}

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

}

}

}

class ThisLockDemo

{

publicstatic void main(String[] args)

{

Tickett = new Ticket();

//两个线程操作的是同一个对象。共享数据是ticket

Threadt1 = new Thread(t);

Threadt2 = new Thread(t);

t1.start();

try{Thread.sleep(10);}catch(Exceptione){}

t.flag= false;

t2.start();

}

}

3. 静态同步函数的锁

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

class Ticket implements Runnable

{

privatestatic int tick = 100;

//Objectobj = new Object();

booleanflag = true;

public void run()

{

if(flag)

{

while(true)

{

synchronized(Ticket.class)

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exceptione){}

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

}

}

}

}

else

while(true)

show();

}

publicstatic synchronized void show()

{

if(tick>0)

{

try{Thread.sleep(10);}catch(Exceptione){}

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

}

}

}

class StaticMethodDemo

{

publicstatic void main(String[] args)

{

Tickett = new Ticket();

Threadt1 = new Thread(t);

Threadt2 = new Thread(t);

t1.start();

try{Thread.sleep(10);}catch(Exceptione){}

t.flag= false;

t2.start();

}

}

静态的同步方法，使用的锁是该方法所在类的字节码文件对象。 类名.class

4. 单例设计模式。

class Single

{

privatestatic Single s = null;

privateSingle(){}

publicstatic Single getInstance()

{

if(s==null)

{

synchronized(Single.class)

{

if(s==null)

s= new Single();

}

}

returns;

}

}

class SingleDemo

{

publicstatic void main(String[] args)

{

System.out.println("HelloWorld!");

}

}

2. 多线程死锁。

class Test implements Runnable

{

privateboolean flag;

Test(booleanflag)

{

this.flag= flag;

}

publicvoid run()

{

if(flag)

{

while(true)

{//假如t1有a锁并进入

synchronized(MyLock.locka)

{

System.out.println(Thread.currentThread().getName()+"...iflocka ");//t1有a但b锁被t2拥有，只有t2执行完下面的语句才会释放b锁，所以t1停止这里。

synchronized(MyLock.lockb)

{

System.out.println(Thread.currentThread().getName()+"..iflockb");

}

}

}

}

else

{

while(true)

{//假如t1阻塞，t2执行，t2有b锁进行

synchronized(MyLock.lockb)

{

System.out.println(Thread.currentThread().getName()+"..elselockb"); 同理t2也被挂在这里。因为t2没有a锁。

synchronized(MyLock.locka)

{

System.out.println(Thread.currentThread().getName()+".....elselocka");

}

}

}

}

}

}

class MyLock

{

staticObject locka = new Object();

staticObject lockb = new Object();

}

class DeadLockTest

{

publicstatic void main(String[] args)

{

Threadt1 = new Thread(new Test(true));

Threadt2 = new Thread(new Test(false));

t1.start();

t2.start();

}

}

3. （*）线程间通信。

当前的线程对象持有的锁对象调用:

wait():当前持有锁的线程对象处于了冻结状

notify():唤醒线程池中首个被冻结的线程。

notifyAll();唤醒线程池中所有的被冻结的线程。

它们都使用在同步中，因为要对持有监视器(锁)的线程操作。所以要使用在同步中，因为只有同步才具有锁。为什么这些操作线程的方法要定义Object类中呢？因为这些方法在操作同步中线程时，都必须要标识它们所操作线程只有的锁，只有同一个锁上的被等待线程，可以被同一个锁上notify唤醒。

不可以对不同锁中的线程进行唤醒。也就是说，等待和唤醒必须是同一个锁。

而锁可以是任意对象，所以可以被任意对象调用的方法定义Object类中。

（因为要被当做锁的对象不确定，即所有对象都要有notify和wait的功能，既然所有类型的对象都要具备这两个功能，那只能定义在Object（上帝）中了，因为所有类都继承自Object）。

1. 示例。



class Res

{

Stringname;

Stringsex;

booleanflag = false;

}

class Input implements Runnable

{

privateRes r ;

Input(Resr)

{

this.r= r;

}

publicvoid run()//input中的run方法

{

intx = 0;

while(true)

{

synchronized(r)

{

if(r.flag)

try{r.wait();}catch(Exceptione){}

if(x==0)

{

r.name="mike";

r.sex="man";

}

else

{

r.name="丽丽";

r.sex= "女女女女女";

}

x = (x+1)%2;

r.flag= true;

r.notify();

}

}

}

}

class Output implements Runnable

{

privateRes r ;

Output(Resr)

{

this.r= r;

}

publicvoid run()

{

while(true)

{

synchronized(r)

{

if(!r.flag)

try{r.wait();}catch(Exceptione){}

System.out.println(r.name+"...."+r.sex);

r.flag= false;

r.notify();

}

}

}

}

class InputOutputDemo

{

publicstatic void main(String[] args)

{

Resr = new Res();

Inputin = new Input(r);

Outputout = new Output(r);

Threadt1 = new Thread(in);

Threadt2 = new Thread(out);

t1.start();

t2.start();

}

}

以上代码的执行过程：

1.创建一个公共数据类Res，创建两个实现Runnable接口的线程对象。

2.创建两个线程对象，将对象传给创建线程的Thread对象用于执行run方法。

3.启动线程t1.t2。t1和t2的run方法不同，但两者操作的都是同一个对象的属性，即共享属性，但是操作的动作不同。这就被称为线程之间的通信。

4.t1线程先被启动，执行in中的run方法。一，第一次执行。二，第二次执行。

publicvoid run()//input中的run方法

{

intx = 0;

while(true)

{//同步前提：1.多线程。2.锁相同。

synchronized(r)//两者使用的是同一个锁

{

if(r.flag)//一1.flag
= false;不执行一6.flag =true

//一.7执行冻结当前线程wait（）会自动抛异常，所以需要处理。

try{r.wait();}catch(Exceptione){}

if(x==0)一2.x=0执行改变name，sex。

{

r.name="mike";

r.sex="man";

}

else

{

r.name="丽丽";

r.sex= "女女女女女";

}

x= (x+1)%2;一3.x=-1;

r.flag= true;一4.flag
= true;

r.notify();一5.唤醒output线程即t2线程开启。

}

}

t2线程被启动，执行out中的run方法。一，第一次执行。二，第二次执行。

class Output implements Runnable

{

privateRes r ;

Output(Resr)

{

this.r= r;

}

publicvoid run()

{

while(true)

{

synchronized(r)

{

//二1.flag = true不执行。

if(!r.flag)//
二5.t2进入冻结状态。 try{r.wait();}catch(Exception e){}

//二2.输出被in修改的name和sex

System.out.println(r.name+"...."+r.sex);

r.flag= false;//二3.flat =false;

r.notify();//二4.唤醒in线程，即t1线程。

}

}

}

}

当t1被唤醒时，t1又开始一的上述步骤。当一5时t2又开始。

2. 解决安全问题。

3. 等待唤醒机制

4. 代码优化。

5. （必须掌握）练习：生产者消费者。

class ProducerConsumerDemo

{

publicstatic void main(String[] args)

{

Resourcer = new Resource();

Producerpro = new Producer(r);

Consumercon = new Consumer(r);

Threadt1 = new Thread(pro);

Threadt2 = new Thread(pro);

Threadt3 = new Thread(con);

Threadt4 = new Thread(con);

t1.start();

t2.start();

t3.start();

t4.start();

}

}

/*

对于多个生产者和消费者。

为什么要定义while判断标记。

原因：让被唤醒的线程再一次判断标记。

为什么定义notifyAll，

因为需要唤醒对方线程。

因为只用notify，容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。

*/

class Resource

{

privateString name;

privateint count = 1;

privateboolean flag = false;

// t1 t2

publicsynchronized void set(String name)

{

while(flag)

try{this.wait();}catch(Exceptione){}//t1(放弃资格) t2(获取资格)

this.name= name+"--"+count++;

System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);

flag= true;

this.notifyAll();

}

// t3 t4

publicsynchronized void out()

{

while(!flag)

try{wait();}catch(Exceptione){}//t3(放弃资格) t4(放弃资格)

System.out.println(Thread.currentThread().getName()+"...消费者........."+this.name);

flag= false;

this.notifyAll();

}

}

class Producer implements Runnable

{

privateResource res;

Producer(Resourceres)

{

this.res= res;

}

publicvoid run()

{

while(true)

{

res.set("+商品+");

}

}

}

class Consumer implements Runnable

{

privateResource res;

Consumer(Resourceres)

{

this.res= res;

}

publicvoid run()

{

while(true)

{

res.out();

}

}

}