---------------------- android培训、java培训 期待与您交流! ----------------------
一:线程间通信。
1,Input -->资源 -->Output
2,思考1:wait(),notifyAll(),用来操作线程为什么定义在了Object类中?
a,这些方法存在于同步中。
b,使用这些方法时必须要表示所属的同步的锁。
c,锁可以使任意对象,所以任意对象调用的方法一定定义Object类中。
思考2:wait(),sleep()有什么区别?
a,wait():释放资源,释放锁。
b,sleep():释放资源,不释放锁。
二:同步.java。
进程:正在执行的程序。
线程:是进程中用于控制程序执行的控制单元(执行路径,执行情景)
进程中至少有一个线程。
对于JVM,启动时,只好有两个线程:jvm的主线程。jvm的垃圾回收线程。
如何在程序中自定义线程呢?
Java给我们提供了对象线程这类事物的描述。该类是Thread
该类中定义了,
创建线程对象的方法(构造函数).
提供了要被线程执行的代码存储的位置(run())
还定义了开启线程运行的方法(start()).
同时还有一些其他的方法用于操作线程:
static Thread currentThead():
String getName():
static void sleep(time)throws InterruptedException:
要运行的代码都是后期定义的。
所以创建线程的第一种方式是:继承Thread类。原因:要覆盖run方法,定义线程要运行的代码。
步骤:
1,继承Thread类。
2,覆盖run方法。将线程要运行的代码定义其中。
3,创建Thread类的子类对象,其实就是在创建线程,调用start方法。
如果自定义的类中有多线程要运行的代码。但是该类有自己的父类。
那么就不可以在继承Thread。怎么办呢?
Java给我们提供了一个规则。Runnable接口。
如果自定义类不继承Thread,也可以实现Runnable接口。并将多线程要运行的代码存放在Runnable的run方法中。
这样多线程也可以帮助该类运行。
这样的操作有一个好处:避免了单继承的局限性。
创建线程的第二种方式:实现Runnable接口。
步骤:
1,定义了实现Runnable接口。
2,覆盖接口的run方法。将多线程要运行的代码存入其中。
3,创建Thread类的对象(创建线程),并将Runnable接口的子类对象作为参数传递给Thread的构造函数。
为什么要传递?因为线程要运行的代码都在Runnable子类的run方法中存储。所以要将该run方法所属的对象
传递给Thread。让Thread线程去使用该对象调用其run方法。
4,调用Thread对象的start方法。开启线程。
动手写代码。
两种方式的特点:
实现方式,因为避免了单继承的局限性,所以创建线程建议使用第二种方式。
##############################
#第一重点:创建线程的两种方式#
##############################
作为了解:
线程的状态。
1,被创建。
2,运行。
3,冻结。
4,消亡。
其实还有一种特殊的状态:临时状态。
该临时状态的特点:
具备了执行资格,但不具备执行权。
冻结状态的特点:
放弃了执行资格。
多线程具备随机性。因为是由cpu不断的快速切换造成的。
就有可能会产生多线程的安全问题。
问题的产生的原因:
几个关键点:
1,多线程代码中有操作共享数据。
2,多条语句操作该共享数据。
当具备两个关键点时,
有一个线程对多条操作共享数据的代码执行的一部分。还没有执行完,另一个线程开始参与执行。
就会发生数据错误。
解决方法:
当一个线程在执行多条操作共享数据代码时,其他线程即使获取了执行权,也不可以参与操作。
Java就对这种解决方式提供了专业的代码。
同步
同步的原理:就是将部分操作功能数据的代码进行加锁。
示例:火车上的卫生间。
同步的表现形式:
1,同步代码块。
2,同步函数。
两者有什么不同:
同步代码块使用的锁是任意对象。
同步函数使用的锁是this。
注意:对于static的同步函数,使用的锁不是this。是 类名.class 是该类的字节码文件对象。
涉及到了单例设计模式的懒汉式。
同步的好处:解决了线程的安全问题。
弊端:
较为消耗资源。
同步嵌套后,容易死锁。
要记住:同步使用的前提:
1,必须是两个或者两个以上的线程。
2,必须是多个线程使用同一个锁。
这是才可以称为这些线程被同步了。
死锁代码一定会写。但开发时一定注意避免。
##############################
#第二重点:同步的所有特性 #
##############################
/*
class Thread
{
private Runnable target;
Thread()
{
}
Thread(Runnable target)
{
this.target = target;
}
public void run()
{
if(target!=null)
target.run();
}
}
class Test implements Runnable
{
public void run()
{}
}
main()
{
Test q = new Test();
Thread t = new Thread(q);
}
class Demo extends Thread
{
public void run()
{
}
}
class
{
public static void main(String[] args)
{
System.out.println("Hello World!");
}
}
*/
三:解决安全问题,等待唤醒机制,代码优化。
/*
线程间通讯:
其实就是多个线程在操作同一个资源,
但是操作的动作不同。
*/
class Res
{
private String name;
private String sex;
private boolean flag = false;
public synchronized void set(String name,String sex)
{
if(flag)
try{this.wait();}catch(Exception e){}
this.name = name;
this.sex = sex;
flag = true;
this.notify();
}
public synchronized void out()
{
if(!flag)
try{this.wait();}catch(Exception e){}
System.out.println(name+"........"+sex);
flag = false;
this.notify();
}
}
class Input implements Runnable
{
private Res r ;
Input(Res r)
{
this.r = r;
}
public void run()
{
int x = 0;
while(true)
{
if(x==0)
r.set("mike","man");
else
r.set("丽丽","女女女女女");
x = (x+1)%2;
}
}
}
class Output implements Runnable
{
private Res r ;
Output(Res r)
{
this.r = r;
}
public void run()
{
while(true)
{
r.out();
}
}
}
class InputOutputDemo2
{
public static void main(String[] args)
{
Res r = new Res();
new Thread(new Input(r)).start();
new Thread(new Output(r)).start();
/*
Input in = new Input(r);
Output out = new Output(r);
Thread t1 = new Thread(in);
Thread t2 = new Thread(out);
t1.start();
t2.start();
*/
}
}
四:线程间通信-生产消费者。
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();
}
}
/*
对于多个生产者和消费者。
为什么要定义while判断标记。
原因:让被唤醒的线程再一次判断标记。
为什么定义notifyAll,
因为需要唤醒对方线程。
因为只用notify,容易出现只唤醒本方线程的情况。导致程序中的所有线程都等待。
*/
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
// t1 t2
public synchronized void set(String name)
{
while(flag)
try{this.wait();}catch(Exception e){}//t1(放弃资格) t2(获取资格)
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
this.notifyAll();
}
// t3 t4
public synchronized void out()
{
while(!flag)
try{wait();}catch(Exception e){}//t3(放弃资格) t4(放弃资格)
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();
}
}
}
五:多线程(线程间通信-生产者消费者JDK5.0升级版)
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 notifyAll,替换了Condition对象。
该对象可以Lock锁 进行获取。
该示例中,实现了本方只唤醒对方操作。
Lock:替代了Synchronized
lock
unlock
newCondition()
Condition:替代了Object wait notify notifyAll
await();
signal();
signalAll();
*/
class Resource
{
private String name;
private int count = 1;
private boolean flag = false;
// t1 t2
private Lock lock = new ReentrantLock();
private Condition condition_pro = lock.newCondition();
private Condition condition_con = lock.newCondition();
public void set(String name)throws InterruptedException
{
lock.lock();
try
{
while(flag)
condition_pro.await();//t1,t2
this.name = name+"--"+count++;
System.out.println(Thread.currentThread().getName()+"...生产者.."+this.name);
flag = true;
condition_con.signal();
}
finally
{
lock.unlock();//释放锁的动作一定要执行。
}
}
// t3 t4
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.signal();
}
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)
{
}
}
}
}
六:停止线程和守护线程。
1,定义循环结束标记。
a,因为线程运行代码一般都是循环,只要控制了循环即可。
2,使用interupt(中断)方法。
b,该方法是结束线程的冻结状态,使线程回到运行状态中来。
注意:stop方法已经过时不再使用。
/*
stop方法已经过时。
如何停止线程?
只有一种,run方法结束。
开启多线程运行,运行代码通常是循环结构。
只要控制住循环,就可以让run方法结束,也就是线程结束。
特殊情况:
当线程处于了冻结状态。
就不会读取到标记。那么线程就不会结束。
当没有指定的方式让冻结的线程恢复到运行状态是,这时需要对冻结进行清除。
强制让线程恢复到运行状态中来。这样就可以操作标记让线程结束。
Thread类提供该方法 interrupt();
*/
class StopThread implements Runnable
{
private boolean flag =true;
public void run()
{
while(flag)
{
System.out.println(Thread.currentThread().getName()+"....run");
}
}
public void changeFlag()
{
flag = false;
}
}
class StopThreadDemo
{
public static void main(String[] args)
{
StopThread st = new StopThread();
Thread t1 = new Thread(st);
Thread t2 = new Thread(st);
t1.setDaemon(true);
t2.setDaemon(true);
t1.start();
t2.start();
int num = 0;
while(true)
{
if(num++ == 60)
{
//st.changeFlag();
//t1.interrupt();
//t2.interrupt();
break;
}
System.out.println(Thread.currentThread().getName()+"......."+num);
}
System.out.println("over");
}
}
七:多线程-join方法。
1,
/*
join:
当A线程执行到了B线程的.join()方法时,A就会等待。等B线程都执行完,A才会执行。
join可以用来临时加入线程执行。
*/
class Demo implements Runnable
{
public void run()
{
for(int x=0; x<70; x++)
{
System.out.println(Thread.currentThread().toString()+"....."+x);
Thread.yield();
}
}
}
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.setPriority(Thread.MAX_PRIORITY);
t2.start();
//t1.join();
for(int x=0; x<80; x++)
{
//System.out.println("main....."+x);
}
System.out.println("over");
}
}
八:多线程-优先级&yield方法。
class MyThread extends Thread{
public void run(){
try {
Thread.currentThread().sleep(3000);
} catch (InterruptedException e) {
}
System.out.println("MyThread running");
}
}
public class ThreadTest{
public static void main(String argv[]) {
MyThread t = new MyThread();
t.run();
t.start();
System.out.println("Thread Test");
}
}
/*
代码分析过程:
MyThread t = new MyThread();
创建了一个线程。
t.run();
调用MyThread对象的run方法。
这是只有一个线程在运行就是主线程。
当主线程执行到了run方法中的sleep(3000);时。
这是主线程处于冻结状态。程序并没有任何执行。
当3秒过后,主线程打印了 MyThread running。 run方法执行结束。
t.start();
开启了t线程。
有两种可能情况。
第一种,主线程在只执行了t.start()后,还具有执行权,继续往下执行,
打印了Thread Test。主线程结束。
t线程获取执行权,调用自己的run方法。然后执行的sleep(3000);冻结3秒。
3秒后,打印MyThread running t线程结束,整个程序结束。
第二种情况:
主线程执行到t.start();开启了t线程,t线程就直接获取到了执行权。
就调用自己的run方法。
指定到sleep(3000).t线程冻结3秒,这是t线程就是释放了执行权。
那么主线程开始执行打印了Thread Test,主线程结束。
等到3秒后,t线程打印MyThread running ,然后t线程结束。
程序结束。
*/
2,
class test_parent
{
int x = 5;
int y = 10;
void set_value(int a, int b)
{
x = a;
y = b;
}
int get_1()
{
return this.x + this.y;
}
int get_2()
{
return x - y;
}
}
class test_4 extends test_parent
{
int y;
test_4(int a)
{
y = a;
}
void set_value(int a, int b)
{
x = a;
y = b;
}
int get_2()
{
return y;
}
}
class Test2
{
public static void main(String[] args)
{
test_4 a1=new test_4(1);
int x = a1.get_1();
System.out.println("x="+x);
}
}
/*
如果用下面几种不同的方法加载类,写出要求的结果:
(3) 用 test_4 a1=new test_4(1) 后;a1.get_1()的内容为_____ 。
(4) 用 test_4 a1=new test_4(-1) ;a1.set _value(5,5) 后;a1.get_2()的内容为
_____。
*/
---------------------- android培训、java培训 期待与您交流! ----------------------