------Java培训、Android培训、iOS培训、.Net培训、期待与您交流! -------
多线程
进程:运行中的程序。程序运行时,内部会有多条执行路径。
线程就是程序中的控制单元 也叫执行路径。
创建多线程的目的,是为了让多部分代码能同时执行。顺便还可以提高效率。
创建线程有两种方式:
创建线程方式一
继承Thread类
1. 子类覆盖父类中的run方法,将线程运行的代码存放在run中。
2. 建立子类对象的同时线程也被创建。
3. 通过调用start方法开启线程。
1. 子类覆盖父类中的run方法,将线程运行的代码存放在run中。
2. 建立子类对象的同时线程也被创建。
3. 通过调用start方法开启线程。
演示:
package mianxiangObject;
public class Today {
public static void main(String[] args) {
new A().start();//创建线程,启动线程。
new Bc().start();
int x=0;
while(x<100)
{
System.out.println(x++);
}
}
}
class A extends Thread
{
public void run()//覆盖Thread类run方法。
{ //run方法中放入要被线程执行的代码。
int x=0;
while(x<100)
{
System.out.println(this.getName()+" x:"+x++);
}
}
}
class Bc extends Thread
{
public void run()
{
int y=0;
while(y<100)
{
System.out.println("y:"+y++);
}
}
}
创建线程方式二
实现Runnable接口
1. 子类覆盖接口中的run方法。
2. 通过Thread类创建线程,并将实现了Runnable接口的子类对象作为参数传递给
Thread类的构造函数。
3. Thread类对象调用start方法开启线程。
3. Thread类对象调用start方法开启线程。
演示
package mianxiangObject;
public class TheradDemo {
public static void main(String[] args) {
new Thread(new Aa()).start();//Runnable接口子类对象作为参数传递给Thread类构造函数。线程启动。
new Thread(new Cc()).start();
}
}
class Aa implements Runnable//实现Runnable接口
{
public void run()//覆盖接口run方法。
{ //run方法中放入要被线程执行的代码。
int x=0;
while(x<100)
{
System.out.println("x:"+x++);
}
}
}
class Cc implements Runnable
{
public void run()
{
int x=100;
while(x>0)
{
System.out.println("y:"+x--);
}
}
}
实现方式和继承方式有什么区别呢?
实现方式好处:避免了单继承的局限性。
在定义线程时,建立使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。
实现方式好处:避免了单继承的局限性。
在定义线程时,建立使用实现方式。
两种方式区别:
继承Thread:线程代码存放Thread子类run方法中。
实现Runnable,线程代码存在接口的子类的run方法。
多个线程同时访问共享数据时,会出现安全问题。
解决方式:线程同步(synchronized)
同步代码块
synchronized(锁对象)
{
需要同步的代码;
}
{
需要同步的代码;
}
同步函数
在函数上加上synchronized修饰符即可。
同步的前提:
同步需要两个或者两个以上的线程。
多个线程使用的是同一个锁。
同步需要两个或者两个以上的线程。
多个线程使用的是同一个锁。
同步的好处:解决了多线程安全问题。
同步的弊端:当线程相当多时,因为每个线程都会去判断同步上的锁,这是很耗费资源的,无形
中会降低程序的运行效率。
中会降低程序的运行效率。
同步函数用的是什么锁呢?
函数需要被对象调用。那么函数都有一个所属对象引用。就是this。
所以同步函数使用的锁是this。
所以同步函数使用的锁是this。
通过该程序进行验证。
使用两个线程来买票。
一个线程在同步代码块中。
一个线程在同步函数中。
都在执行买票动作。
一个线程在同步代码块中。
一个线程在同步函数中。
都在执行买票动作。
class Ticket implements Runnable
{
private int tick = 100;
Object obj = new Object();
boolean flag = true;
public void run()
{
if(flag)
{
while(true)
{
synchronized(this)//this锁
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....code : "+ tick--);
}
}
}
}
else
while(true)
show();
}
public synchronized void show()//this
{
if(tick>0)
{
try{Thread.sleep(10);}catch(Exception e){}
System.out.println(Thread.currentThread().getName()+"....show.... : "+ tick--);
}
}
}
class ThisLockDemo
{
public static void main(String[] args)
{
Ticket t = new Ticket();
Thread t1 = new Thread(t);
Thread t2 = new Thread(t);
t1.start();//运行同步代码块中的代码。
try{Thread.sleep(10);}catch(Exception e){}
t.flag = false;
t2.start();//<span style="font-family: 微软雅黑;">运行同步函数中的代码。</span>
经过验证,发现同步代码块中是this锁时,线程同步。
说明用的是this锁。
如果同步函数被静态修饰后,使用的锁是什么呢?
通过验证,发现不在是this。因为静态方法中也不可以定义this。
静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
通过验证,发现不在是this。因为静态方法中也不可以定义this。
静态进内存是,内存中没有本类对象,但是一定有该类对应的字节码文件对象。
类名.class 该对象的类型是Class
静态的同步方法,使用的锁是该方法所在类的字节码文件对象。 类名.class
特殊情况:死锁 同步中嵌套同步
原因:A线程拿着a锁,B线程拿着b锁,当A线程要继续执行时需要b锁,B线程要继续执行时需要a锁,这
时候就会产生死锁现象。
练习:写一个死锁。
//死锁练习。
public class ElseTestSisuo {
public static void main(String[] args) {
new Thread(new Test(true)).start();
new Thread(new Test(false)).start();
}
}
class Test implements Runnable
{
private boolean flag;
Test(boolean flag)
{
this.flag=flag;
}
public void run()
{
if(flag)
{
while(true)
{
synchronized(Mylock.locka)
{ System.out.println("if heima a");
synchronized(Mylock.lockb)
{
System.out.println("if heima b");
}
}
}
}
else
{
while(true)
{
synchronized(Mylock.lockb)
{ System.out.println("else heima b");
synchronized(Mylock.locka)
{
System.out.println("else heima a");
}
}
}
}
}
}
class Mylock// 此类专门用于提供锁 。
{
static Object locka = new Object();
static Object lockb = new Object();
}
线程间通讯:
其实就是多个线程在操作同一个资源,但是操作的动作不同。
wait:
notify();
notifyAll();
都使用在同步中,因为要对持有监视器(锁)的线程操作。
所以要使用在同步中,因为只有同步才具有锁。
为什么这些操作线程的方法要定义Object类中呢?
因为这些方法在操作同步中线程时,都必须要标识它们所操作线程只有的锁,
只有同一个锁上的被等待线程,可以被同一个锁上notify唤醒。
不可以对不同锁中的线程进行唤醒。
也就是说,等待和唤醒必须是同一个锁。
而锁可以是任意对象,所以可以被任意对象调用的方法定义Object类中。
JDK1.5 中提供了多线程升级解决方案。
将同步Synchronized替换成现实Lock操作。
将Object中的wait,notify notifyAll,替换了Condition对象。
该对象可以Lock锁进行获取。
可以实现本方只唤醒对方操作。
Lock:替代了Synchronized
lock ();
unlock ();
newCondition();
Condition:替代了Object wait notify notifyAll
await();
signal();
signalAll();
将同步Synchronized替换成现实Lock操作。
将Object中的wait,notify notifyAll,替换了Condition对象。
该对象可以Lock锁进行获取。
可以实现本方只唤醒对方操作。
Lock:替代了Synchronized
lock ();
unlock ();
newCondition();
Condition:替代了Object wait notify notifyAll
await();
signal();
signalAll();
以上内容为本人笔记,仅供参考。