多线程

多线程

一，线程概述

1，进程

●在操作系统中每个独立执行的程序都可称为一个进程，也就是“正在运行的程序”。

2，线程

●每个运行的程序都是一个进程，在一个进程中还可以多个执行单元同时运行，这些执行单元可以看作程序执行的一条条线索，被称为线程。

3，线程的创建方式

●●创建线程方式一

继承Thread类

①子类覆盖父类中的run方法，将线程运行的代码存放在run中。

②建立子类对象的同时线程也被创建。

③通过调用start方法开启线程。

例：/*
进程：是一个正在执行中的程序。
每一个进程执行都有一个执行顺序，该顺序是一个执行路径，
或者叫一个控制单元。
线程：就是进程中的一个独立的控制单元。
线程在控制着进程的执行。


一个进程中至少有一个线程。


java VM 启动的时候会有一个进程java.exe。


该进程中至少一个线程负责java程序的执行。
而且这个线程运行的代码存在于main方法中。
该线程称之为主线程。


扩展：其实更细节说明jvm，jvm启动不止一个线程，还有负责垃圾回收机制的线程。


1，如何在自定义的代码中，自定义一个线程？
通过对api的查找，java已经提供了对线程这类事物的描述，就是Thread类。
创建线程的第一种方式：继承Thread类。
步骤：
1，定义类继承Thread。
2，复写Thread类中的run方法。
目的：将自定义的代码存储在run方法中，让线程运行。
3，调用线程的start方法，
该方法有两个作用：启动线程，调用run方法。


发现运行结果每一次都不同。
因为多个线程都获取cpu的执行权。cpu执行到谁，谁就运行。
明确一点，在某一个时刻，只能有一个程序在运行。（多核除外）
cpu在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象把多线程的运行行为在互相抢夺cpu的执行权。


这就是多线程的一个特性：随机性。谁抢到谁执行，至于执行多长时间，cpu说了算。


为什么要覆盖run方法呢？


Thread类用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码。


也就是说Thread类中的run方法，用于存储线程要运行的代码。


*/
class Demo extends Thread
{
public void run ()
{
for (int x=0;x<60 ;x++ )
System.out.println("demo run~~~"+x);
}
}
class ThreadDemo 
{
public static void main(String[] args) 
{
//for(x=0;x<100 ;x++ )
// System.out.println("Hello World!");
Demo d = new Demo();//创建好一个线程。
//d.start();//开启线程并执行该线程的run方法。
d.run();//仅仅是对象调用方法，而线程创建了，并没有运行。
for(x=0;x<60 ;x++ )
System.out.println("Hello World!~~~"+x);
}
}

线程的四种状态：

※sleep方法需要指定睡眠时间，单位是毫秒。

※一个特殊的状态：就绪。具备了执行资格，但是还没有获取资源。

●●创建线程方式二

实现Runnable接口

①子类覆盖接口中的run方法。

②通过Thread类创建线程，并将实现了Runnable接口的子类对象作为参数传递给Thread类的构造函数。

③Thread类对象调用start方法开启线程。

二，线程安全问题

1，导致安全问题的出现的原因：

●多个线程访问出现延迟。

●线程随机性。

注:线程安全问题在理想状态下，不容易出现，但一旦出现对软件的影响是非常大的。

三，同步（synchronized）

格式：

synchronized (对象)

{

需要同步的代码；

}

同步可以解决安全问题的根本原因就在那个对象上。该对象如同锁的功能。

1，同步特点

●同步的前提：

①同步需要两个或者两个以上的线程。

②多个线程使用的是同一个锁。

未满足这两个条件，不能称其为同步。

同步的弊端：

当线程相当多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率。

/*
死锁程序。
*/


class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag=flag;
}
public void run ()
{
if(flag)
{
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("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();
}
}

2，同步函数

格式：在函数上加上synchronized修饰符即可。

例：class ProducerConsumerDemo 
{
public static void main(String[] args) 
{
Resource r = new Resource();


Producer pro =new Producer(r);
Consumer con =new Consumer(r);


Thread t1 = new Thread (pro);
Thread t2 = new Thread (pro);
Thread t3 = new Thread (con);
Thread t4 = new Thread (con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Resource
{
private String name;
private int count=1;
private boolean flag = false;


public synchronized void set(String name)
{
while(flag)
try{wait();}catch(Exception e){}
this.name = name+"..."+count++;
System.out.println(Thread.currentThread().getName()+".......生产者.."+this.name);
flag = true;
this.notifyAll();
}
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
flag = false;
this.notifyAll();
}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run ()
{
while(true)
{
res.set("+商品+");
}
}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run ()
{
while(true)
{
res.out();
}
}
}

三，停止线程

1，定义循环结束标记

●     因为线程运行代码一般都是循环，只要控制了循环即可。

2，使用interrupt（中断）方法。

●该方法是结束线程的冻结状态，使线程回到运行状态中来。

注：stop方法已经过时不再使用。

/*
通过分析，发现，打印出0，-1，-2等错票。


多线程的运行出现了安全问题。


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


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


java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized（对象)
{
需要被同步的代码块；
}
对象如同锁，持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。


火车上的卫生间---经典。


同步的前提：
1，必须要有两个或者两个以上的线程。
2，必须是多个线程使用同一个锁。


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


好处：解决了多线程的安全问题。
弊端：多个线程需要判断锁，较为消耗资源。


*/
class Ticket implements Runnable //extends Thread
{
private int tick=100;
Object obj = new Object();
public void run ()
{
while(true)
{
synchronized(obj)
{
if(tick>0)
{
System.out.println(Thread.currentThread().getName()+"..."+tick--);
}
}
}
}
}
class TicketDemo2 
{
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 Res
{
String name;
String sex;
}
class Input implements Runnable
{
private Res r;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
synchronized(r )
{
if(x==0)
{
r.name="mike";
r.sex= "man";
}
else
{
r.name="丽丽";
r.sex="女";
}
}
x=(x+1)%2;
}
}
}
class Output implements Runnable
{
private Res r ;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
synchronized(r)
{
System.out.println(r.name+"..."+r.sex);
}
}
}
}
class InputOutputDemo 
{
public static void main(String[] args) 
{
Res r = new Res();
Input in = new Input(r);
Output out = new Output(r);


Thread t1=new Thread(in);
Thread t2 = new Thread (out);


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

import java.util.concurrent.locks.*;


class ProducerConsumerDemo2 
{
public static void main(String[] args) 
{
Resource r = new Resource();


Producer pro =new Producer(r);
Consumer con =new Consumer(r);


Thread t1 = new Thread (pro);
Thread t2 = new Thread (pro);
Thread t3 = new Thread (con);
Thread t4 = new Thread (con);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
/*
JDK1.5中提供了多线程升级解决方方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait，notify nottifyAll，替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中，实现了本方只唤醒对方的操作。
*/
class Resource
{
private String name;
private int count=1;
private boolean flag = false;


private Lock lock = new ReentrantLock();
private Condition condition_con = lock.newCondition();
private Condition condition_pro = lock.newCondition();
public synchronized void set(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
condition_pro.await();
this.name = name+"..."+count++;
System.out.println(Thread.currentThread().getName()+".......生产者.."+this.name);
flag = true;
condition_con.signalAll();
}
finally
{
lock.unlock();//释放锁的动作一定要执行。
}


}
public void out()throws InterruptedException
{ 
lock.lock();
try
{
while(!flag)
condition_con.await();
System.out.println(Thread.currentThread().getName()+"...消费者.."+this.name);
flag = false;
condition_pro.signalAll();
}
finally
{
lock.unlock();
}


}
}
class Producer implements Runnable
{
private Resource res;
Producer(Resource res)
{
this.res = res;
}
public void run ()
{
while(true)
{
try
{
res.set("+商品+");
}
catch (InterruptedException e)
{
}

}
}
}
class Consumer implements Runnable
{
private Resource res;
Consumer(Resource res)
{
this.res = res;
}
public void run ()
{
while(true)
{
try
{
res.out();
}
catch (InterruptedException e)
{
}
}
}
}

/*
join:
当A线程执行到了B线程的.join()方法是时，A就会等待。等B线程都执行完，A才会执行。
join可以用来临时加入线程执行。


*/
class Demo implements Runnable
{
public void run ()
{
for (int x=1;x<70 ;x++ )
{
System.out.println(Thread.currentThread().getName()+"..."+x);


}
}
}
class JoinDemo 
{
public static void main(String[] args)throws Exception 
{
Demo d = new Demo();
Thread t1= new Thread(d);
Thread t2= new Thread(d);
t1.start();
t1.join();
t2.start();
for (int x=0;x<80 ;x++ )
{
System.out.println("main..."+x);
}
System.out.println("over");
}
}