线程创建方式和线程同步

一:创建线程方式:
1.  继承Thread,然后重写run()方法
例如: 
public class ThreadOne extends Thread {
    @Override
    public void run() {
        Log.i("TAG","创建线程方式1");
    }
}


启动线程方式start
 ThreadOne one = new ThreadOne();
        one.start();


2.实现runable接口
例如:
public class ThreadTwo implements Runnable {
    @Override
    public void run() {
        Log.i("TAG","创建线程方式2");
    }
}
 Thread thread = new Thread(new ThreadTwo());
        thread.start();
3.通过Callable和Future创建线程


public class FetureThread implements Callable {
    int a = 0;


    @Override
    public Integer call() throws Exception {
        for(int i = 0 ; i < 8; i++ ){
            a++;
        }
        return a;
    }
}


public class Future {
    FetureThread fetureThread = new FetureThread();
    FutureTask task = new FutureTask(fetureThread);
    public void run(){
      Thread t = new Thread(task);
        t.start();
    }
    public Integer getResult(){
        try {
            return  task.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        return 0;
    }
}


Future future = new Future();
        future.run();
        Log.i("HomeActivity 线程执行结果",future.getResult()+"");
以上三种创建线程的方式比较:


使用继承Thread类的方式创建多线程时优势是:


编写简单,如果需要访问当前线程
线程类已经继承了Thread类,所以不能再继承其他父类
采用实现Runnable、Callable接口的方式创见多线程时,优势是:


线程类只是实现了Runnable接口或Callable接口,还可以继承其他类,同时使用Callable
还可以获取线程执行的结果
二:线程同步方式:
1.synchronized,
当用此关键字修饰方法时, 内置锁会保护整个方法。在调用该方法前,需要获得内置锁,否则就处于阻塞状态。
注: synchronized关键字也可以修饰静态方法,此时如果调用该静态方法,将会锁住整个类。
:同步是一种高开销的操作,因此应该尽量减少同步的内容。通常没有必要同步整个方法,使用synchronized代码块同步关键代码即可。


public class MoneyThread implements Runnable {


    @Override
    public void run() {
        synchronized (this){
            for(int i = 0; i < 10 ;i++){
                Log.i("HomeActivity " +"执行结果"+ Thread.currentThread().getName(),(++i)+"");
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}


MoneyThread moneyThread = new MoneyThread();
        Thread t1 = new Thread(moneyThread,"线程1");
        t1.start();
        Thread t2 = new Thread(moneyThread,"线程2");
        t2.start();


执行结果:


  执行结果线程1: 1
01-14 22:22:25.957 21985-22005/? I/HomeActivity 执行结果线程1: 3
01-14 22:22:25.967 21985-22005/? I/HomeActivity 执行结果线程1: 5
01-14 22:22:25.967 21985-21985/? D/InputTransport: Input channel constructed: name='440c7c98 com.examply (client)', fd=57
01-14 22:22:25.977 21985-22005/? I/HomeActivity 执行结果线程1: 7
01-14 22:22:25.987 21985-22005/? I/HomeActivity 执行结果线程1: 9
01-14 22:22:26.007 21985-22006/? I/HomeActivity 执行结果线程2: 1
01-14 22:22:26.017 21985-22006/? I/HomeActivity 执行结果线程2: 3
01-14 22:22:26.027 21985-22006/? I/HomeActivity 执行结果线程2: 5
01-14 22:22:26.037 21985-22006/? I/HomeActivity 执行结果线程2: 7
01-14 22:22:26.052 21985-22006/? I/HomeActivity 执行结果线程2: 9


当两个并发线程(thread1和thread2)访问同一个对象(syncThread)中的synchronized代码块时,
在同一时刻只能有一个线程得到执行,另一个线程受阻塞,必须等待当前线程执行完这个代码
块以后才能执行该代码块。Thread1和thread2是互斥的,因为在执行synchronized代码块时会
锁定当前的对象,只有执行完该代码块才能释放该对象锁,下一个线程才能执行并锁定该对象


我们稍作修改:


 Thread t1 = new Thread(new MoneyThread(),"线程1");
        t1.start();
        Thread t2 = new Thread(new MoneyThread(),"线程2");
        t2.start();

执行结果:
01-14 22:28:35.572 28140-28159/? I/HomeActivity 执行结果线程1: 1
01-14 22:28:35.572 28140-28160/? I/HomeActivity 执行结果线程2: 1
01-14 22:28:35.582 28140-28160/? I/HomeActivity 执行结果线程2: 3
01-14 22:28:35.582 28140-28159/? I/HomeActivity 执行结果线程1: 3
01-14 22:28:35.587 28140-28140/? D/InputTransport: Input channel constructed: name='45044e78 com.example.yybj.myapplication/com.example.yybj.myapplication.HomeActivity (client)', fd=57
01-14 22:28:35.592 28140-28160/? I/HomeActivity 执行结果线程2: 5
01-14 22:28:35.592 28140-28159/? I/HomeActivity 执行结果线程1: 5
01-14 22:28:35.602 28140-28160/? I/HomeActivity 执行结果线程2: 7
01-14 22:28:35.602 28140-28159/? I/HomeActivity 执行结果线程1: 7
01-14 22:28:35.612 28140-28160/? I/HomeActivity 执行结果线程2: 9
01-14 22:28:35.612 28140-28159/? I/HomeActivity 执行结果线程1: 9




不是说一个线程执行synchronized代码块时其它的线程受阻塞吗?为什么上面的
例子中thread1和thread2同时在执行。这是因为synchronized只锁定对象,
每个对象只有一个锁(lock)与之相关联


这时创建了两个SyncThread的对象syncThread1和syncThread2,线程thread1执行的是
syncThread1对象中的synchronized代码(run),而线程thread2执行的是syncThread2对象
中的synchronized代码(run);我们知道synchronized锁定的是对象,这时会有两把锁分别锁定
syncThread1对象和syncThread2对象,而这两把锁是互不干扰的,不形成互斥,
所以两个线程可以同时执行


2.给指定的对象加锁:
public class OpeateThread implements Runnable {
    Money money;


    public OpeateThread(Money money) {
        this.money = money;
    }


    @Override
    public void run() {
        try {
            synchronized (money){
                money.save(500);
                money.getMoney(500);
                Log.i("HomeActivity " +"执行结果"+ Thread.currentThread().getName(),
                        "现在的账户余额"+money.getResult()+"");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}


 Money account = new Money(10000,"李四");
        OpeateThread accountOperator = new OpeateThread(account);


        final int THREAD_NUM = 5;
        Thread threads[] = new Thread[THREAD_NUM];
        for (int i = 0; i < THREAD_NUM; i ++) {
            threads[i] = new Thread(accountOperator, "线程" + i);
            threads[i].start();
        }


执行结果:
96-9540/com.example.yybj.myapplication I/HomeActivity 执行结果线程0: 现在的账户余额10000
01-14 22:42:03.917 9496-9544/com.example.yybj.myapplication I/HomeActivity 执行结果线程4: 现在的账户余额10000
01-14 22:42:03.937 9496-9542/com.example.yybj.myapplication I/HomeActivity 执行结果线程2: 现在的账户余额10000
01-14 22:42:03.957 9496-9541/com.example.yybj.myapplication I/HomeActivity 执行结果线程1: 现在的账户余额10000
01-14 22:42:03.977 9496-9543/com.example.yybj.myapplication I/HomeActivity 执行结果线程3: 现在的账户余额10000




当有一个明确的对象作为锁时,就可以用类似下面这样的方式写程序。
public void method3(SomeObject obj)
{
   //obj 锁定的对象
   synchronized(obj)
   {
      // todo
   }
}


当没有明确的对象作为锁,只是想让一段代码同步时,可以创建一个特殊的对象来充当锁:


class Test implements Runnable
{
   private byte[] lock = new byte[0];  // 特殊的instance变量
   public void method()
   {
      synchronized(lock) {
         // todo 同步代码块
      }
   }


   public void run() {


   }
}


说明:零长度的byte数组对象创建起来将比任何对象都经济――查看编译后的字节码:
生成零长度的byte[]对象只需3条操作码,而Object lock = new Object()则需要7行操作码。




修饰一个方法


Synchronized作用于整个方法的写法。 
写法一:


public synchronized void method()
{
   // todo
}


写法二:


public void method()
{
   synchronized(this) {
      // todo
   }
}
写法一修饰的是一个方法,写法二修饰的是一个代码块,
但写法一与写法二是等价的,都是锁定了整个方法时的内容




修饰一个静态的方法
Synchronized也可修饰一个静态方法,用法如下:


public synchronized static void method() {
   // todo
}


我们知道静态方法是属于类的而不属于对象的。同样的,synchronized修饰的静态方
法锁定的是这个类的所有对象。 




package com.example.yybj.myapplication;


import android.util.Log;


/**
 * Created by YYBJ on 2018/1/14.
 */


public class StaticMoneyThread implements Runnable {
    private static int a = 0;


    @Override
    public synchronized void run() {
        test();
    }


    private synchronized static void test() {
        for (int i = 0; i < 5; i++) {
            Log.i("HomeActivity " + "执行结果" +
                    Thread.currentThread().getName(), (a += i) + "");
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}


执行结果:01-14 23:00:59.877 28433-28467/com.example.yybj.myapplication I/HomeActivity 执行结果线程1: 0
01-14 23:00:59.887 28433-28467/com.example.yybj.myapplication I/HomeActivity 执行结果线程1: 1
01-14 23:00:59.887 28433-28433/com.example.yybj.myapplication D/InputTransport: Input channel constructed: name='44083f28 com.example.yybj.myapplication/com.example.yybj.myapplication.HomeActivity (client)', fd=58
01-14 23:00:59.897 28433-28467/com.example.yybj.myapplication I/HomeActivity 执行结果线程1: 3
01-14 23:00:59.907 28433-28467/com.example.yybj.myapplication I/HomeActivity 执行结果线程1: 6
01-14 23:00:59.917 28433-28467/com.example.yybj.myapplication I/HomeActivity 执行结果线程1: 10
01-14 23:00:59.957 28433-28468/com.example.yybj.myapplication I/HomeActivity 执行结果线程2: 10
01-14 23:00:59.967 28433-28468/com.example.yybj.myapplication I/HomeActivity 执行结果线程2: 11
                                                                                      
                                                                                      [ 01-14 23:00:59.972 28433:28433 E/         ]
                                                                                      mali: REVISION=Linux-r3p1-01rel1 BUILD_DATE=Tue Jul  2 15:06:24 KST 2013 
01-14 23:00:59.982 28433-28468/com.example.yybj.myapplication I/HomeActivity 执行结果线程2: 13
01-14 23:00:59.992 28433-28468/com.example.yybj.myapplication I/HomeActivity 执行结果线程2: 16
01-14 23:01:00.007 28433-28468/com.example.yybj.myapplication I/HomeActivity 执行结果线程2: 20




syncThread1和syncThread2是SyncThread的两个对象,但在thread1和thread2并发执行时却保持了线程同步。
这是因为run中调用了静态方法method,而静态方法是属于类的,所以syncThread1和syncThread2相当于用了同一把锁


总结:
 无论synchronized关键字加在方法上还是对象上,如果它作用的对象是非静态的,则它取得的锁是对象;
 如果synchronized作用的对象是一个静态方法或一个类,则它取得的锁是对类,该类所有的对象同一把锁。 
B. 每个对象只有一个锁(lock)与之相关联,谁拿到这个锁谁就可以运行它所控制的那段代码。 
C. 实现同步是要很大的系统开销作为代价的,甚至可能造成死锁,所以尽量避免无谓的同步控制




在多线程的情况下,由于同一进程的多个线程共享同一片存储空间,在带来方便的同时,也带来了访问冲突这个严重的问题。
Java语言提供了专门机制以解决这种冲突,有效避免了同一个数据对象被多个线程同时访问。
 wait与notify是java同步机制中重要的组成部分
 在调用wait的时候,线程自动释放其占有的对象锁,同时不会去申请对象锁。当线程被唤醒的时候,它才再次获得了去获得对象锁的权利。
wait(),notify(),notifyAll()不属于Thread类,而是属于Object基础类,也就是说每个对像都有wait(),notify(),notifyAll()的功能。
因为都个对像都有锁,锁是每个对像的基础
通常,多线程之间需要协调工作:如果条件不满足,则等待;当条件满足时,等待该条件的线程将被唤醒。在Java中,这个机制的实现依
于wait/notify。等待机制与锁机制是密切关联的。最常见的就是生产者消费者模型
例如:
  synchronized(obj) {
  while(!condition) {
  obj.wait();
  }
  obj.doSomething();
  }
  
  当线程A获得了obj锁后,发现条件condition不满足,无法继续下一处理,于是线程A就wait()。
  在另一线程B中,如果B更改了某些条件,使得线程A的condition条件满足了,就可以唤醒线程A :
  
  synchronized(obj) {
  condition = true;
  obj.notify();
  }
  
  需要注意的概念是:
  
  # 调用obj的wait(), notify()方法前,必须获得obj锁,也就是必须写在synchronized(obj){...} 代码段内。
  
  # 调用obj.wait()后,线程A就释放了obj的锁,否则线程B无法获得obj锁,也就无法在synchronized(obj){...} 代码段内唤醒A。
  
  # 当obj.wait()方法返回后,线程A需要再次获得obj锁,才能继续执行。
  
  #如果A1,A2,A3都在obj.wait(),则B调用obj.notify()只能唤醒A1,A2,A3中的一个(具体哪一个由JVM决定)。


线程同步方式2:Lock


ReentrantLock类 
作用跟synchronized代码块差不多,都是用于实现互斥,当然两者是有区别的。
Condition接口 
它提供了await()、signal()、signalAll()等方法,作用于Object类的wait()、signal()和signalAll()方法一样。
注意由于它是一个接口,因此是不能new出来的,我们必须通过ReentrantLock类的newCondition方法得到一个
Condition对象(实际上是ConditionObject类对象),这个对象与该ReentrantLock对象相关联。
同样,Condition的await()、signal()、signalAll()都必须在获得相对应的ReentrantLock锁才能进行调用


注意这里我们可以使用同一个ReentrantLock对象多次调用newCondition获得多个Condition对象,以实现更加
复杂的同步关系,而使用Object类的相当于只能有一个Condition对象。当然,在不同的Condition对象中,
等待和唤醒要相对应,比如说,我们两次调用newCondition方法,得到了两个Condition对象condition1和condition2,
假如我在线程A调用condition1.await(),然后线程B调用了condition2.signal(),那么线程A是一定不会因此被唤醒的,
而应该调用condition1.signal()线程A才可能会被唤醒,为什么说可能而不是一定呢?原因是signal()同Object类的
notify()是一样的,系统会随机唤醒等待集中的一个线程,而我们的线程A不一定会被选到。


每次lock完都必须要在finally块中执行unLock。


线程池:
线程池+ 阻塞队列综合使用
  ExecutorService executorService =  Executors.newSingleThreadExecutor();
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                Log.i("HomeActivity","线程池使用----------");
            }

        });

这个是线程池的核心:

线程创建方式和线程同步_第1张图片

线程创建方式和线程同步_第2张图片

重点看下Worker;

线程创建方式和线程同步_第3张图片

线程创建方式和线程同步_第4张图片

所以在向线程池里面添加任务的时候,如果小于核心线程数的话,那就线程池会继续创建线程,如果超过了核心线程数

那么就会把新到来的任务添加到阻塞队列,当阻塞队列添加满了的时候(ArrayBlockingQueue因为有容量),还有新的任务

到来的时候就会继续创新新的线程,如果此时线程池里面线程数量小于最大线程数的话,如果还有新的任务到来,就会拒绝

所以在线程池里面创建线程的时候,线程数量和核心线程数,最大线程数,阻塞队列都有关系.

所以我们在创建线程池的时候,推荐使用ThreadPoolExecutor()这种方式来创建线程池,这样子开发者可以很清楚的知道线程池里面每一个参数的含义,对于Executors这种方式创建线程池的时候,不推荐,其中newFixedThreadPool,newSingleThreadExecutor,这两种创建线程池的时候在任务量很大的时候会导致OOM,根本原因就是阻塞队列采用的是LinkedBlockingQueue,而LinkedBlockingQueue的大小为Integer.MAX_VALUE,对于,newCachedThreadPool和ScheduledThreadPoolExecutor他们的阻塞队列都不大(这句话不严谨,读者可以看源码就明白了),这种方式创建的线程池,在任务数据多的话,频繁的创建线程,可能会出现OOM,在创建线程的时候要设置线程的名字和group,多打印日志,方便后期对于线程池的分析和系统优化分析.





























































































你可能感兴趣的:(线程)