一、多线程
进程是什么
正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。
线程是什么
其实就是进程中一个程序执行控制单元，一条执行路径。进程负责的是应用程序的空间的标示。
线程负责的是应用程序的执行顺序。
一个进程至少有一个线程在运行，当一个进程中出现多个线程时，就称这个应用程序是多线程应用程序。
java中的线程
在java中，JVM虚拟机启动时，会有一个进程为java.exe，该程序中至少有一个线程负责java程序的执行。
而且该程序运行的代码存在于main方法中，该线程称之为主线程。其实，JVM启动时不止有一个线程（主线程）
由于java是具有垃圾回收机制的，所以，在进程中，还有负责垃圾回收机制的线程。
二、 创建线程的方式
方式一继承Thread类
/**
第一、定义类继承Thread。
第二、复写Thread类中的run方法。
第三、调用线程的start方法。分配并启动该子类的实例。
start方法的作用：启动线程，并调用run方法。
*/
class Demo extends Thread
{
public void run()
{
for (int i=0;i<60;i++)
System.out.println(Thread.currentThread().getName() + "demo run---" + i);
}
}
public class Temp
{
public static void main(String[] args)
{
Demo d1 = new Demo();//创建一个对象就创建好了一个线程
d1.start();//开启线程并执行run方法
}
}
Run方法与start方法的区别：
Run：是让自定义代码存储，让线程运行。
start：启运线程调用方式，调用Run方法
发现运行结果，每一次都不一样因为多个线程，都在获取CPU的执行权，CPU执行到谁，谁就运行。
明确一点，在某一时刻，只能有一个程序在运行，（多核除外）
CPU在做着快速的切换，以达到看上去是同时运行的效果。
我们可以形象的把多线程的运行，形容为：在互相抢CPU的资源，这就是多线程的特性：随机性。就是谁抢到，谁运行，至于执行多长时间，CPU说了算。
为什么要覆盖Run方法呢、
Thread类用于描述线程。
该类就定义了一个功能，用于存储线程要运行的代码。该存储功能就是Run方法
也就是说：Thread类中的Run方法，用于存储线程要运行的代码。
创建线程方式二：实现Runnable接口
/**
第一、定义类实现Runnable接口。
第二、覆盖Runnable接口中的run方法。
第三、通过Thread类建立线程对象。要运行几个线程，就创建几个对象。
第四、将Runnable接口的子类对象作为参数传递给Thread类的构造函数。
第五、调用Thread类的start方法开启线程，并调用Runnable接口子类的run方法。
*/
//多个窗口同时卖票
class Ticket implements Runnable
{
private int tic = 10;
public void run()
{
while(true)
{
if (tic > 0)
System.out.println(Thread.currentThread().getName() + "sale:" + tic--);
}
}
}
public class Temp
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);//创建一个线程
Thread t2 = new Thread(t);//创建一个线程
t1.start();
t2.start();
}
}继承Thread 和 实现Runnable区别：
实现方式好处：避免了单线程的局限性
在定义线程时，建议使用（实现方式）Runnable线程方式
区别
继承Thread：线程代码存放在Thread子类run方法中
实现Runnable：线程代码存放在接口的子类run方法中
三、线程状态运行图
图解
阻塞状态：具备运行资格，但是没有执行权，必须等到cpu的执行权，才转到运行状态。
冻结状态：放弃了cpu的执行资格，cpu不会将执行权分配给这个状态下的线程，必须被唤醒后，此线程要先转换到阻塞状态
等待cpu的执行权后，才有机会被执行到。
四、多线程安全问题
线程同步
同步的前提：
1、同步需要两个或者两个以上的线程
2、多个线程使用的是同一个锁。
3、未满足这两个条件，不能称其为同步。
同步的弊端
当线程相当多时，因为每个线程都会去判断 同步上的锁，这是很耗费资源的，无形 中会降低程序的运行效率。
/*
银行：有一个金库
* 有两个储户分别存300元，每次存100，存3次
*
* 目的：该程序是否有安全问题《如果有，如何解决？》
*
* 如何找问题：
* 1，明确哪些代码是多线程运行代码
* 2，明确共享数据
* 3，明确多线程运行代码中哪些语句是操作共享数据的。、
*
* 同步数据方法，可以放在函数上
*/
class Bank
{
private int sum;
public synchronized void Add(int num)
{
sum = sum + num;
System.out.println(Thread.currentThread().getName()+"sum:"+sum);
}
}
class Cus implements Runnable
{
private Bank b = new Bank();
public void run()
{
for(int x=0;x<3;x++)
{
b.Add(100);
}
}
}
public class Temp {
public static void main(String[]args)
{
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}同步代码块
/*
通过分析，发现，打印出0，-1，-2等错票。
多线程的运行出现了安全问题。
问题的原因：
当多条语句在操作同一个线程共享数据时，一个线程对多条语句只执行了一部分，还没有执行完，
另一个线程参与进来执行。导致共享数据的错误。
解决办法：
对多条操作共享数据的语句，只能让一个线程都执行完。在执行过程中，其他线程不可以参与执行。
Java对于多线程的安全问题提供了专业的解决方式。
就是同步代码块。
synchronized(对象)
{
需要被同步的代码
}
对象如同锁。持有锁的线程可以在同步中执行。
没有持有锁的线程即使获取cpu的执行权，也进不去，因为没有获取锁。
*/
class Ticket implements Runnable
{
private int tick = 1000;
Object obj = new Object();
public void run()
{
while(true)
{
synchronized(obj) //同步锁
{
if(tick>0)
{
//try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....sale : "+ tick--);
}
}
}
}
}
class Temp
{
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();
}
}
同步函数
/**
* 同步函数用的是哪一个锁呢？
* 函数需要被对象调用，那么函数都有一个所属对象引用。就是this.
* 所以同步函数使用的锁是this.
*
* 通过该程序进行验证
*
* 使用两个线程来卖票
* 一个线程在同步代码块中。
* 一个线程在同步函数中。
* 都在执行卖票动物。
* 重点：
* 先让主线程停止10毫秒，当程序执行到t2后，执行一会儿，主线程突然醒了，然后执行主线程
* 如果同步函数被静态修饰后，使用的锁是什么呢？
* 通过验证，发现不再是this.（因为静态方法中也不可以定义this）
* 静态进内存时，内存中没有本类对象，但是一定有该类的字节码文件对象。
* 类名.class 该对象的类型是 Class
* 静态的同步方法，使用的锁是该方法所在类的字节码文件对象。类名.class
*/
class DemoTecket implements Runnable
{
private int ticket = 100;
Object obj = new Object();
boolean flag = true;
public void run()
{
if(flag)
{
while(true)
{
//如果show方法被静态修饰，这里调用的对象是DemoTicket.class
synchronized(this)//因为run方法调用的show()方法，show方法调用的是this.所以这里是this
{
if(ticket>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"...同步售票："+ticket--);
}
}
}
}
else
{
while(true)
{
show();
}
}
}
public synchronized void show()
{
if(ticket>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"...函数售票："+ticket--);
}
}
}
public class Temp{
public static void main(String[]args)
{
DemoTecket dt = new DemoTecket();
Thread t1 = new Thread(dt);
Thread t2 = new Thread(dt);
Thread t3 = new Thread(dt);
Thread t4 = new Thread(dt);
t1.start();
//重点：先让主线程停止10毫秒，当程序执行到t2后，执行一会儿，主线程突然醒了，然后执行主线程
try{Thread.sleep(10);}catch(Exception e){}
dt.flag=false;
t2.start();
//t3.start();
//t4.start();
}
}
静态同步函数的锁是class对象
/*
* 用两个线程进行：卖票
* 同步函数用的是哪一个锁呢？
* 函数需要被对象调用，那么函数都有一个所属对象引用。就是this.
* 所以同步函数使用的锁是this.
* 如何找问题：
* 1，明确哪些代码是多线程运行代码
* 2，明确共享数据
* 3，明确多线程运行代码中哪些语句是操作共享数据的。、
* 如果同步函数被静态修饰后，使用的锁是什么呢？'
* 通过验证，发现不在是this，因为静态方法中，不可以定义this
* 我们可以这样想，
* 静态进入内存的时候，是没有本类对象的，首先加载的是“类” 所以一定会有该类对应的字节码文件对象(类名.class)
* 类进入内存，会建立一个字节码文件对象。
* 由此推断-->被静态修饰的同步方法锁：用的是class（类）
* 静态的同步方法，使用的锁是该方法所在的字节码文件对象. 类名.class
*/
class TicketDemo implements Runnable
{
//将票私有500张票
private static int tick = 100;
//定义一个标记，用来调用两个线程
boolean flag = true;
//覆盖runnable中的run方法
public void run()
{
if(flag)
{
//打印车票
while(true)
{
//如果show方法被静态修饰，这里调用的对象是Ticket.class
synchronized(TicketDemo.class)//因为run方法调用的show()方法，show方法调用的是this.所以这里是this
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"同步售票"+tick--);
}
}
}
}
else
while(true)
show();
}
//对操作共享数据的代码块进行封装
public static synchronized void show()
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
//currentThread();获取线程名称
System.out.println(Thread.currentThread().getName()+"..同步函数售票.."+tick--);
}
}
}
public class Temp{
public static void main(String[]args)
{
TicketDemo t = new TicketDemo();
//创建线程
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();
//当主函数执行到这儿时，让它停留10秒;原因是，main主函数线程会瞬间将两个线程开启执行，
//所以当线程执行到t.falg=false时，会直接执行到show方法
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t2.start();
}
}
线程死锁
//定义锁的对象
class Dea implements Runnable
{
//定义一个标记
private boolean flag;
//初始化
Dea(boolean flag)
{
this.flag = flag;
}
//覆盖Run方法
public void run()
{
//创建同步锁，并互相嵌套
if(flag)
{
synchronized(Lock.lockA)
{
System.out.println("Lock.lockA");
synchronized(Lock.lockB)
{
System.out.println("Lock.lockB");
}
}
}
else
{
synchronized(Lock.lockB)
{
System.out.println("Lock.lockB");
synchronized(Lock.lockA)
{
System.out.println("Lock.lockA");
}
}
}
}
}
//创建锁对象
//加static：原因是可以直接用类名.lock访问
class Lock
{
static Object lockA = new Object();
static Object lockB = new Object();
}
public class Temp {
public static void main(String[]args)
{
Thread t1 = new Thread(new Dea(true));
Thread t2 = new Thread(new Dea(false));
t1.start();
t2.start();
}
}
线程间通信
多线程间通信是线程之间进行交互的方式，简单说就是存储资源和获取资源。比如说仓库中的货物，有进货的，有出货的。
还比如生产者和消费者的例子。这些都可以作为线程通信的实例。那么如何更好地实现通信呢？先看下面的代码：
/*
线程间通信：
生产者消费者 多个
*/
import java.util.concurrent.locks.*;
class ProducerConsumerDemo{
public static void main(String[] args){
Resouse r = new Resouse();
Producer p = new Producer(r);
Consumer c = new Consumer(r);
Thread t1 = new Thread(p);
Thread t2 = new Thread(c);
Thread t3 = new Thread(p);
Thread t4 = new Thread(c);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Resouse{
private String name;
private int count = 1;
private boolean flag = false;
private Lock lock = new ReentrantLock();
private Condition condition_P = lock.newCondition();
private Condition condition_C = lock.newCondition();
//要唤醒全部，否则都可能处于冻结状态，那么程序就会停止。这和死锁有区别的。
public void set(String name)throws InterruptedException{
lock.lock();
try{
while(flag)//循环判断，防止都冻结状态
condition_P.await();
this.name = name + "--" + count++;
System.out.println(Thread.currentThread().getName() + "..生成者--" + this.name);
flag = true;
condition_C.signal();
}finally{
lock.unlock();//释放锁的机制一定要执行
}
}
public void out()throws InterruptedException{
lock.lock();
try{
while(!flag)//循环判断，防止都冻结状态
condition_C.await();
System.out.println(Thread.currentThread().getName() + "..消费者." + this.name);
flag = false;
condition_P.signal();//唤醒全部
}finally{
lock.unlock();
}
}
}
class Producer implements Runnable{
private Resouse r;
Producer(Resouse r){
this.r = r;
}
public void run(){
while(true){
try{
r.set("--商品--");
}catch (InterruptedException e){}
}
}
}
class Consumer implements Runnable{
private Resouse r;
Consumer(Resouse r){
this.r = r;
}
public void run(){
while(true){
try{
r.out();
}catch (InterruptedException e){}
}
}
}JDK1.5中升级Lock
/*
* Lock：锁
* ReentrantLock: 重复锁定
* Lock lock = new ReentrantLock();//Lock类下的子类对象，创建可重复使用的锁
* |--lock：锁定...相当于synchronized
* |--unlock：释放锁
* condition：条件、身份
* |--await：等待
* |--signal：发送信号，唤醒一个等待线程
* |--signalAll：唤醒所有等待线程
* InterruptedException:中断异常
* JDK1.5中提供了升级版多线程解决方案。
* 将同步Synchronized替换成显示Lock操作。
* 将Object中的wait\notify()\notifyAll,替换成了Condition对象
* 该对可以Lock锁，进行获取，同时可以创建多个锁对象
* 在该实例中，实现了本方只唤醒对方的操作。
*/
import java.util.concurrent.locks.*;
class Ress
{
private String name;
private String sex;
boolean flag = false;
//Lock类下的子类对象，创建可重复使用的锁
private Lock lock = new ReentrantLock();
//返回绑定到此Lock实例的新Condition实例 其实就是可以建立多个身份的锁
Condition condition_pro = lock.newCondition();//生产锁对象
Condition condition_con = lock.newCondition();//消费锁对象
public void set(String name,String sex)throws InterruptedException
{
lock.lock();
try
{
while(flag)
{
condition_pro.await();//生产锁等待
}
this.name = name;
this.sex = sex;
flag = true;
condition_con.signal();//唤醒消费
}
finally
{
lock.unlock();//释放锁的动作，一定要执行。
}
}
public void out()throws InterruptedException
{
lock.lock();
try
{
while(!flag)
{
condition_con.await();//消费锁等待
}
System.out.println(this.name+".."+this.sex);
flag = false;
condition_pro.signal();//唤醒生产
}
finally
{
lock.unlock();
}
}
}
class Inputt implements Runnable
{
private Ress r;
Inputt(Ress r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
try
{
if(x==0)
{
r.set("MIKE", "Man");
}
else
{
r.set("麦克", "女");
}
x=(x+1)%2;
}
catch(InterruptedException e)
{}
}
}
}
class Outt implements Runnable
{
private Ress r;
Outt(Ress r)
{
this.r = r;
}
public void run()
{
try
{
while(true)
{
r.out();
}
}
catch(InterruptedException e)
{}
}
}
public class Temp {
public static void main(String[]args)
{
Resours res = new Resours();
Producer pro = new Producer(res);
Consumer con = new Consumer(res);
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();
}
}
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
