------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
一 进程和线程
1 进程
正在进行中的程序。其实进程就是一个应用程序运行时的内存分配空间。一个进程中可以有多个线程。比如在Windows系统中,一个运行的xx.exe就是一个进程。
2 线程
其实就是进程中一个程序执行控制单元,一条执行路径。进程负责的是应用程序的空间的标示。线程负责的是应用程序的执行顺序。
3 多线程
一个进程至少有一个线程在运行,当一个进程中出现多个线程时,就称这个应用程序是多线程应用程序,每个线程在栈区中都有自己的执行空间,自己的方法区、自己的变量。
jvm在启动的时,首先有一个主线程,负责程序的执行,调用的是main函数。主线程执行的代码都在main方法中。
当产生垃圾时,收垃圾的动作,是不需要主线程来完成,因为这样,会出现主线程中的代码执行会停止,会去运行收垃圾的线程。
一个进程至少有一个线程,为了提高效率,可以在一个进程中开启多个控制单元。
并发运行。如:多线程下载软件。
可以完成同时运行,但是通过程序运行的结果发现,虽然同时运行,但是每一次结果都不一致。
因为多线程存在一个特性:随机性。
随机性的原理:因为cpu的快速切换造成,哪个线程获取到了cpu的执行权,哪个线程就执行。
4 线程与进程的比较
线程具有许多传统进程所具有的特征,故又称为轻型进程(Light—Weight Process)或进程元;而把传统的进程称为重型进程(Heavy—Weight Process),它相当于只有一个线程的任务。在引入了线程的操作系统中,通常一个进程都有若干个线程,至少需要一个线程。
进程与线程的区别:
1.进程有独立的进程空间,进程中的数据存放空间(堆空间和栈空间)是独立的。
2.线程的堆空间是共享的,栈空间是独立的,线程消耗的资源也比进程小,相互之间可以影响的。
二 线程创建方式
1,创建线程的第一种方式:
继承Thread ,由子类复写run方法。
步骤:
1),定义类继承Thread类。
2),复写run方法,将要让线程运行的代码都存储到run方法中;
3),通过创建Thread类的子类对象,创建线程对象;
4),调用线程的start方法,开启线程,并执行run方法。
Example:
//定义类继承Thread类
class ThreadDemo extends Thread
{
private String name;
ThreadDemo(String name)
{
super(name);
}
//复写run()方法。
public void run()
{
for(int x=1;x<=60;x++)
{
System.out.println(Thread.currentThread().getName()+"::"+x);
}
}
public static void main(String[] args)
{
new ThreadDemo("第一线程").start();//创建Thread类的子类对象,并开启线程。
new ThreadDemo("第二线程").start();
for(int x=0;x<10;x++)
{
System.out.println("Hello world!");
}
}
}
2,创建线程的第二种方式:
实现一个接口Runnable。
步骤:
1),定义类实现Runnable接口。
2),覆盖接口中的run方法(用于封装线程要运行的代码)。
3),通过Thread类创建线程对象;
4),将实现了Runnable接口的子类对象作为实际参数传递给Thread类中的构造函数。
为什么要传递呢?因为要让线程对象明确要运行的run方法所属的对象。
5),调用Thread对象的start方法。开启线程,并运行Runnable接口子类中的run方法。
Example:
//通过实现Runnable接口的方式创建线程。
class ThreadDemo1 implements Runnable
{
private int ticket=50;
public void run()
{
while(ticket>0)
{
System.out.println(Thread.currentThread().getName()+"卖出了第"+(ticket--)+"号票");
}
}
public static void main(String[] args)
{
ThreadDemo1 t=new ThreadDemo1();//创建实现Runnable接口的子类对象。
new Thread(t,"第一窗口").start();//创建并开启线程。
new Thread(t,"第二窗口").start();
new Thread(t,"第三窗口").start();
new Thread(t,"第四窗口").start();
new Thread(t,"第五窗口").start();
System.out.println("Hello world!");
}
}
3 线程状态:
被创建:start()
运行:具备执行资格,同时具备执行权;
冻结:sleep(time),wait()—notify()唤醒;线程释放了执行权,同时释放执行资格;
临时阻塞状态:线程具备cpu的执行资格,没有cpu的执行权;
消亡:stop()
4 两种进程创建方式比较
A extends Thread:
简单
不能再继承其他类了(Java单继承)
同份资源不共享
A implements Runnable:(推荐)
多个线程共享一个目标资源,适合多线程处理同一份资源。
该类还可以继承其他类,也可以实现其他接口。
为什么要有Runnable接口的出现?
1:通过继承Thread类的方式,可以完成多线程的建立。但是这种方式有一个局限性,如果一个类已经有了自己的父类,就不可以继承Thread类,因为java单继承的局限性。
可是该类中的还有部分代码需要被多个线程同时执行。这时怎么办呢?
只有对该类进行额外的功能扩展,java就提供了一个接口Runnable。这个接口中定义了run方法,其实run方法的定义就是为了存储多线程要运行的代码。
所以,通常创建线程都用第二种方式。
因为实现Runnable接口可以避免单继承的局限性。
2:其实是将不同类中需要被多线程执行的代码进行抽取。将多线程要运行的代码的位置单独定义到接口中。为其他类进行功能扩展提供了前提。
所以Thread类在描述线程时,内部定义的run方法,也来自于Runnable接口。
实现Runnable接口可以避免单继承的局限性。而且,继承Thread,是可以对Thread类中的方法,进行子类复写的。但是不需要做这个复写动作的话,只为定义线程代码存放位置,实现Runnable接口更方便一些。所以Runnable接口将线程要执行的任务封装成了对象。
三 多线程安全问题:
一个线程在执行多条语句时,并运算同一个数据时,在执行过程中,其他线程参与进来,并操作了这个数据。导致到了错误数据的产生。
涉及到两个因素:
1,多个线程在操作共享数据。
2,有多条语句对共享数据进行运算。
原因:这多条语句,在某一个时刻被一个线程执行时,还没有执行完,就被其他线程执行了。
解决安全问题的原理:
只要将操作共享数据的语句在某一时段让一个线程执行完,在执行过程中,其他线程不能进来执行就可以解决这个问题。
如何进行多句操作共享数据代码的封装呢?
java中提供了一个解决方式:就是同步代码块。
格式:
synchronized(对象) { // 任意对象都可以。这个对象就是锁。
需要被同步的代码;
}
同步:
持有锁的线程可以在同步中 执行。
好处:解决了线程安全问题。
弊端:相对降低性能,因为判断锁需要消耗资源,产生了死锁。
定义同步是有前提的:
1,必须要有两个或者两个以上的线程,才需要同步。
2,多个线程必须保证使用的是同一个锁。
同步的第二种表现形式:
同步函数:其实就是将同步关键字定义在函数上,让函数具备了同步性。
同步函数是用的哪个锁呢?
通过验证,函数都有自己所属的对象this,所以同步函数所使用的锁就是this锁。
当同步函数被static修饰时,这时的同步用的是哪个锁呢?
静态函数在加载时所属于类,这时有可能还没有该类产生的对象,但是该类的字节码文件加载进内存就已经被封装成了对象,这个对象就是该类的字节码文件对象。
所以静态加载时,只有一个对象存在,那么静态同步函数就使用的这个对象。
这个对象就是 类名.class
同步代码块和同步函数的区别?
同步代码块使用的锁可以是任意对象。
同步函数使用的锁是this,静态同步函数的锁是该类的字节码文件对象。
在一个类中只有一个同步,可以使用同步函数。如果有多同步,必须使用同步代码块,来确定不同的锁。所以同步代码块相对灵活一些。
Example:
/*
1.同步代码块
*/
class TicketThreadDemo implements Runnable
{
private int ticket=100;
Object obj=new Object();
public void run()
{
//同步代码块
synchronized(obj)
{
while(ticket>0)
{
try
{
Thread.sleep(10);//模拟线程出现的安全问题
}
catch (Exception e)
{
}
System.out.println(Thread.currentThread().getName()+"卖出了第"+(ticket--)+"号票");
}
}
}
public static void main(String[] args)
{
TicketThreadDemo t=new TicketThreadDemo();
new Thread(t,"1号窗口").start();//开启线程
new Thread(t,"2号窗口").start();
System.out.println("Hello world!");
}
}
Example:
/*
2.同步函数
*/
class TicketThreadDemo2 implements Runnable
{
private int ticket=100;
public void run()
{
show();
}
//同步函数
public synchronized void show()
{
while(ticket>0)
{
try
{
Thread.sleep(100);
}
catch (Exception e)
{
}
System.out.println(Thread.currentThread().getName()+":::"+(ticket--));
}
}
public static void main(String[] args)
{
TicketThreadDemo2 t=new TicketThreadDemo2();
Thread t1=new Thread(t,"1");//创建线程。
Thread t2=new Thread(t,"2");
t1.start();//开旗县城。
t2.start();
}
}
Example;
/*
3.静态同步函数
*/
class Single
{
private Single(){};
private static Single s=null;
public static Single getInstance()
{
if(s==null)
synchronized(Single.class)
{
if(s==null)
{
s=new Single();
}
}
return s;
}
public static void main(String[] args)
{
System.out.println("Hello world!");
}
}
四 同步死锁
同步死锁:通常只要将同步进行嵌套,就可以看到现象。同步函数中有同步代码块,同步代码块中还有同步函数。
Example:
/*
一个死锁示例。
*/
class DeadLockDemo implements Runnable
{
private boolean flag;//定义标记。
DeadLockDemo(boolean flag)
{
this.flag=flag;
}
public void setFlag(boolean flag)
{
this.flag=flag;
}
public void run()//复写run(0方法。
{
if(flag)
{
while(true)
{
synchronized(LockDemo.locka)//locka锁。
{
System.out.println(Thread.currentThread().getName()+"if_locka");
synchronized(LockDemo.lockb)//lockb锁。
{
System.out.println(Thread.currentThread().getName()+"if_lockb");
}
}
}
}
else
{
while(true)
{
synchronized(LockDemo.lockb)
{
System.out.println(Thread.currentThread().getName()+"else_lockb");
synchronized(LockDemo.locka)
{
System.out.println(Thread.currentThread().getName()+"else_locka");
}
}
}
}
}
public static void main(String[] args)
{
new Thread(new DeadLockDemo(true)).start();
new Thread(new DeadLockDemo(false)).start();
}
}
class LockDemo
{
static Object locka=new Object();
static Object lockb=new Object();
}
五 线程间通信
线程间通信:思路:多个线程在操作同一个资源,但是操作的动作却不一样。
1:将资源封装成对象。
2:将线程执行的任务(任务其实就是run方法。)也封装成对象。
等待唤醒机制:涉及的方法:等待唤醒必须是同一把锁。
wait:将同步中的线程处于冻结状态。释放了执行权,释放了资格。同时将线程对象存储到线程池中。
notify:唤醒线程池中某一个等待线程。
notifyAll:唤醒的是线程池中的所有线程。
注意:
1:这些方法都需要定义在同步中。
2:因为这些方法必须要标示所属的锁。
你要知道 A锁上的线程被wait了,那这个线程就相当于处于A锁的线程池中,只能A锁的notify唤醒。
3:这三个方法都定义在Object类中。为什么操作线程的方法定义在Object类中?
因为这三个方法都需要定义同步内,并标示所属的同步锁,既然被锁调用,而锁又可以是任意对象,那么能被任意对象调用的方法一定定义在Object类中。
wait和sleep区别: 分析这两个方法:从执行权和锁上来分析:
wait:可以指定时间也可以不指定时间。不指定时间,只能由对应的notify或者notifyAll来唤醒。
sleep:必须指定时间,时间到自动从冻结状态转成运行状态(临时阻塞状态)。
wait:线程会释放执行权,而且线程会释放锁。
Sleep:线程会释放执行权,但不是不释放锁。
Exampple:
/*
线程间通信
*/
class Teacher
{
private String name;
private String sex;
private boolean flag=false;//定义标记
public synchronized void set(String name,String sex)
{
if(flag)
{
try{wait(); }catch (Exception e){}
}
this.name=name;
this.sex=sex;
flag=true;
this.notify();//唤醒
}
public synchronized void get()
{
if(!flag)
{
try{wait();}catch (Exception e){}
}
System.out.println(name+";"+sex);
flag=false;
this.notify();//唤醒
}
}
class TeacherSet implements Runnable
{
private Teacher t;
TeacherSet(Teacher t)
{
this.t=t;
}
public void run()
{
int x=0;
while(true)
{
if(x==0)
{
t.set("刘德华","男");
}
else
{
t.set("刘亦菲","女");
}
x=(x+1)%2;
}
}
}
class TeacherGet implements Runnable
{
private Teacher t;
TeacherGet(Teacher t)
{
this.t=t;
}
public void run()
{
while(true)
{
t.get();
}
}
}
class TeacherDemo
{
public static void main(String[] args)
{
Teacher t=new Teacher();
new Thread(new TeacherSet(t)).start();
new Thread(new TeacherGet(t)).start();
}
}
六 线程的停止
线程的停止:通过stop方法就可以停止线程。但是这个方式过时了。
停止线程:原理就是:让线程运行的代码结束,也就是结束run方法。
怎么结束run方法?一般run方法里肯定定义循环。所以只要结束循环即可。
第一种方式:定义循环的结束标记。
第二种方式:如果线程处于了冻结状态,是不可能读到标记的,这时就需要通过Thread类中的interrupt方法,将其冻结状态强制清除。让线程恢复具备执行资格的状态,让线程可以读到标记,并结束。
interrupt():中断线程。
setPriority(int newPriority):更改线程的优先级。
getPriority():返回线程的优先级。
static int MAX_PRIORITY
线程可以具有的最高优先级。
static int MIN_PRIORITY
线程可以具有的最低优先级。
static int NORM_PRIORITY
分配给线程的默认优先级。
toString():返回该线程的字符串表示形式,包括线程名称、优先级和线程组。
Thread.yield():暂停当前正在执行的线程对象,并执行其他线程。
setDaemon(true):将该线程标记为守护线程或用户线程。将该线程标记为守护线程或用户线程。当正在运行的线程都是守护线程时,Java 虚拟机退出。该方法必须在启动线程前调用。
join:临时加入一个线程的时候可以使用join方法。
当A线程执行到了B线程的join方式。A线程处于冻结状态,释放了执行权,B开始执行。A什么时候执行呢?只有当B线程运行结束后,A才从冻结状态恢复运行状态执行。
七 Lock接口
Lock接口:多线程在JDK1.5版本升级时,推出一个接口Lock接口。
但是由于synchronized是在JVM层面实现的,因此系统可以监控锁的释放与否,而ReentrantLock使用代码实现的,系统无法自动释放锁,需要在代码中finally子句中显式释放锁lock.unlock();
使用建议:
在并发量比较小的情况下,使用synchronized是个不错的选择,但是在并发量比较高的情况下,其性能下降很严重,此时ReentrantLock是个不错的方案。
解决线程安全问题使用同步的形式,(同步代码块,要么同步函数)其实最终使用的都是锁机制。
到了后期版本,直接将锁封装成了对象。线程进入同步就是具备了锁,执行完,离开同步,就是释放了锁。
在后期对锁的分析过程中,发现,获取锁,或者释放锁的动作应该是锁这个事物更清楚。所以将这些动作定义在了锁当中,并把锁定义成对象。
所以同步是隐示的锁操作,而Lock对象是显示的锁操作,它的出现就替代了同步。
在之前的版本中使用Object类中wait、notify、notifyAll的方式来完成的。那是因为同步中的锁是任意对象,所以操作锁的等待唤醒的方法都定义在Object类中。
而现在锁是指定对象Lock。所以查找等待唤醒机制方式需要通过Lock接口来完成。而Lock接口中并没有直接操作等待唤醒的方法,而是将这些方式又单独封装到了一个对象中。这个对象就是Condition,将Object中的三个方法进行单独的封装。并提供了功能一致的方法 await()、signal()、signalAll()体现新版本对象的好处。
Example:
/*java.util.concurrent.locks > Condition接口:await()、signal()、signalAll();
*/
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
}
finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
}
finally {
lock.unlock();
}
}
}
Example;
import java.util.concurrent.locks.*;
class LockDemo1
{
public static void main(String[] args)
{
Resource r=new Resource();
new Thread(new Producer(r)).start();
new Thread(new Consumer(r)).start();
}
}
class Producer implements Runnable
{
private Resource r;
Producer(Resource r)
{
this.r=r;
}
public void run()
{
while(true)
{
r.set("商品");
}
}
}
class Consumer implements Runnable
{
private Resource r;
Consumer(Resource r)
{
this.r=r;
}
public void run()
{
while(true)
{
r.get();
}
}
}
class Resource
{
private String name;
private int count=1;
private boolean flag=false;
Lock lock=new ReentrantLock();
//创建Condition对象。
Condition pro=lock.newCondition();
Condition con=lock.newCondition();
public void set(String name)
{
lock.lock();//锁
try
{
while(flag)
pro.await();//如果标记为真,生产方等待
this.name=name+"..."+count;
System.out.println(Thread.currentThread().getName()+"生产了"+name+"..."+count);
flag=true;
con.signal();//唤醒消费方
}
catch(Exception e)
{
}
finally
{
lock.unlock();
}
}
public void get()
{
lock.lock();
try
{
while(!flag)
con.await();//如果为假,消费方等待。
System.out.println(Thread.currentThread().getName()+"消费了"+name);
flag=false;
pro.signal();//唤醒生产方。
}
catch(Exception e)
{
}
finally
{
lock.unlock();
}
}
}