------- android培训、java培训、期待与您交流! ----------
1.多线程概述:
进程:正在进行中的程序(直译)。
线程:就是进程中一个负责程序执行的控制单元(执行路径), 一个进程中可以多执行路径,称之为多线程。 一个进程中至少要有一个线程。
开启多个线程是为了同时运行多部分代码。 每一个线程都有自己运行的内容。这个内容可以称为线程要执行的任务。
多线程好处:解决了多部分同时运行的问题。
多线程的弊端:线程太多回到效率的降低。
其实应用程序的执行都是cpu在做着快速的切换完成的,这个切换是随机的。 JVM启动时就启动了多个线程,至少有两个线程可以分析的出来。 1,执行main函数的线程,
该线程的任务代码都定义在main函数中。 2,负责垃圾回收的线程。
2.线程创建方法:
创建线程方式一:继承Thread类。
步骤:
1,定义一个类继承Thread类。 2,覆盖Thread类中的run方法。
3,直接创建Thread的子类对象创建线程。
4,调用start方法开启线程并调用线程的任务run方法执行。
可以通过Thread的getName获取线程的名称 Thread-编号(从0开始)
主线程的名字就是main。
class Demo extends Thread {
private String name;
Demo(String name) {
super(name);
//this.name = name; }
public void run() {
for(int x=0; x<10; x++) {
System.out.println(name+"....x="+x+".....name="+Thread.currentThread().getName());
}
}
}
class ThreadDemo2 {
public static void main(String[] args) {
Demo d1 = new Demo("旺财");
Demo d2 = new Demo("xiaoqiang");
d1.start();//开启线程,调用run方法。
d2.start();
System.out.println("over...."+Thread.currentThread().getName());
}
}
创建线程的第二种方式:实现Runnable接口
步骤:
1,定义类实现Runnable接口。
2,覆盖接口中的run方法,将线程的任务代码封装到run方法中。
3,通过Thread类创建线程对象,并将Runnable接口的子类对象作为Thread类的构造函数的参数进行传递。 为什么?因为线程的任务都封装在Runnable接口子类对象的run方法中。 所以要在线程对象创建时就必须明确要运行的任务。 4,调用线程对象的start方法开启线程。
实现Runnable接口的好处:
1,将线程的任务从线程的子类中分离出来,进行了单独的封装。 按照面向对象的思想将任务的封装成对象。 2,避免了java单继承的局限性。
所以,创建线程的第二种方式较为常用。
class Demo implements Runnable{
public void run() {
show();
}
public void show() {
for(int x=0; x<20; x++) {
System.out.println(Thread.currentThread().getName()+"....."+x);
}
}
}
class ThreadDemo {
public static void main(String[] args) {
Demo d = new Demo();
Thread t1 = new Thread(d);
Thread t2 = new Thread(d);
t1.start();
t2.start();
}
}
3.线程安全问题
线程安全问题产生的原因:
1,多个线程在操作共享的数据。
2,操作共享数据的线程代码有多条。
当一个线程在执行操作共享数据的多条代码过程中,其他线程参与了运算。 就会导致线程安全问题的产生。
解决思路;
就是将多条操作共享数据的线程代码封装起来,当有线程在执行这些代码的时候, 其他线程时不可以参与运算的。
必须要当前线程把这些代码都执行完毕后,其他线程才可以参与运算。 在java中,利用同步代码块或同步方法,jdk5.0的lock就可以解决此类问题。
同步代码块的格式:
synchronized(对象) {
需要被同步的代码 ;
}
同步的好处:解决了线程的安全问题。
同步的弊端:相对降低了效率,因为同步外的线程的都会判断同步锁。 同步的前提:同步中必须有多个线程并使用同一个锁。
静态的同步函数使用的锁是该函数所属字节码文件对象,
可以用 getClass方法获取,也可以用当前类名.class 表示。
同步函数的使用的锁是this;
同步函数和同步代码块的区别:
同步函数的锁是固定的this, 同步代码块的锁是任意的对象。 建议使用同步代码块。
案例:
多线程典型案例之银行存钱
/*
* 需求:储户,两个,每个都到银行存钱每次存100,,共存三次。
*/
class Bank {
private int sum;
// private Object obj = new Object();
// 同步函数
public synchronized void add(int num){
sum = sum + num;
try{Thread.sleep(10);}catch(InterruptedException e){}
System.out.println("sum="+sum);
}
}
class Cus implements Runnable {
private Bank b = new Bank();
public void run() {
for(int x=0; x<3; x++) {
b.add(100);
}
}
}
class BankDemo {
public static void main(String[] args) {
Cus c = new Cus();
Thread t1 = new Thread(c);
Thread t2 = new Thread(c);
t1.start();
t2.start();
}
}
4.死锁
产生情况:同步里面还有同步而且用的不同的锁
典型死锁案例之同步代码块嵌套
package cn.djb.thread;
public class DeadLockTest {
/**
* @param args
*/
public static void main(String[] args) {
A a1=new A(false);
A a2=new A(true);
Thread t1=new Thread(a1);
Thread t2=new Thread(a2);
t1.start();
t2.start();
}
}
class A implements Runnable{
private boolean flag;
public A(boolean b){
this.flag=b;
}
public void run() {
if(flag){
synchronized (Lock.locka) {
System.out.println("if locka");
synchronized (Lock.lockb) {
System.out.println("if lockb");
}
}
}
else{
synchronized (Lock.lockb) {
System.out.println("else lockb");
synchronized (Lock.locka) {
System.out.println("else locka");
}
}
}
}
}
class Lock{
public static Object locka=new Object();
public static Object lockb=new Object();
}
5.多线程下的单例(懒汉式)
package cn.djb.single;
public class Single {
private Single(){};
private static Single s=null;
public static Single getSingle(){
if(s==null){
synchronized (Single.class) {
if(s==null){
s=new Single();
return s;
}
return s;
}
}
return s;
}
}
6.线程等待唤醒机制:
线程状态图:
wait() 释放执行资格,线程处于等待状态
notify() 唤醒对方第一个处于等待状态的线程
notifyAll() 唤醒对方所有处于等待状态的线程
案例:
package cn.djb.thread;
/*
* 要求:给一个对象设置一个人名和性别,然后才可以取走,取走后才可以再设置,如此交替
*/
public class WaitNotifyTest {
/**
* @param args
*/
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();
}
}
class Res {
private String name;
private String sex;
private boolean s;
public boolean isS() {
return s;
}
public void setS(boolean s) {
this.s = s;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
}
class Input implements Runnable {
private Res r;
private boolean b;
public Input(Res r) {
this.r = r;
}
public void run() {
for (int i = 0; i < 1000; i++) {
synchronized (r) {
if (r.isS())
try {
r.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
if (b) {
r.setName("张三");
r.setSex("男");
this.b = false;
} else {
r.setName("lili");
r.setSex("female");
this.b = true;
}
r.setS(true);
r.notify();
}
}
}
}
class Output implements Runnable {
private int num;
private Res r;
public Output(Res r) {
this.r = r;
}
public void run() {
for (int i = 0; i < 1000; i++) {
synchronized (r) {
if (r.isS()) {
System.out.println(r.getName() + "=" + r.getSex());
num++;
r.setS(false);
r.notify();
} else {
try {
r.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
if (i == 999)
System.out.println(num);
}
}
}
多生产者与多消费者案例:
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升级版多生产者与消费者lock锁:
jdk1.5以后将同步和锁封装成了对象。 并将操作锁的隐式方式定义到了该对象中, 将隐式动作变成了显示动作。
Lock接口: 出现替代了同步代码块或者同步函数。将同步的隐式锁操作变成现实锁操作。 同时更为灵活。可以一个锁上加上多组监视器。 lock():获取锁。
unlock():释放锁,通常需要定义finally代码块中。
Condition接口:出现替代了Object中的wait notify notifyAll方法。 将这些监视器方法单独进行了封装,变成Condition监视器对象。 可以任意锁进行组合。
await(); signal(); signalAll();
package cn.djb.thread;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
public class ThreadLockTest {
/**
* @param args
*/
public static void main(String[] args) {
Resource r=new Resource();
Productor p=new Productor(r);
Customer c=new Customer(r);
Thread t1=new Thread(p);
Thread t2=new Thread(p);
Thread t3=new Thread(c);
Thread t4=new Thread(c);
t1.start();
t2.start();
t3.start();
t4.start();
}
}
class Resource{
private String name;
private int number=0;
private boolean flag;
private Lock lock=new ReentrantLock();
private Condition condition_pro=lock.newCondition();
private Condition condition_cus=lock.newCondition();
public void sale() {
lock.lock();
try{
while(!flag)
condition_cus.await();
System.out.println(Thread.currentThread().getName()+"............"+"sale"+name+number);
flag=false;
condition_pro.signal();
}catch (Exception e) {
}finally{
lock.unlock();
}
}
public void product(String name) {
lock.lock();
try{
while(flag)
condition_pro.await();
this.name = name;
this.number++;
System.out.println(Thread.currentThread().getName()+"..."+"product"+this.name+this.number);
flag=true;
condition_cus.signal();
}catch (Exception e) {
}
finally{
lock.unlock();
}
}
}
class Productor implements Runnable{
private Resource r;
public Productor(Resource r){
this.r=r;
}
public void run() {
for(int i=0;i<600;i++)
r.product("北京烤鸭");
}
}
class Customer implements Runnable{
private Resource r;
public Customer(Resource r){
this.r=r;
}
public void run() {
for(int i=0;i<600;i++)
r.sale();
}
}