多线程系列1:入门

1 源码介绍

Thread 中run代码

 @Override    public void run() {        if (target != null) {            target.run();        }    }

target对象是指

   private Runnable target;

runable接口代码

public interface Runnable {    /**     * When an object implementing interface <code>Runnable</code> is used     * to create a thread, starting the thread causes the object's     * <code>run</code> method to be called in that separately executing     * thread.     * <p>     * The general contract of the method <code>run</code> is that it may     * take any action whatsoever.     *     * @see     java.lang.Thread#run()     */    public abstract void run();}

2 如何创建线程

      1 通过覆盖父类run方法

      2 为父类提供target(即runable)对象

3 代码实战

public class ThreadDemo {public static void main(String[] args) throws Exception {//创建方式1Thread thread = new Thread(){@Overridepublic void run() {for (int i = 0; i < 20; i++) {try {Thread.sleep(500);System.out.println("name--1"+Thread.currentThread().getName());} catch (InterruptedException e) {e.printStackTrace();}}}};//thread startthread.start();//创建方式2Thread thread2 = new Thread(new Runnable() {@Overridepublic void run() {for (int i = 0; i < 20; i++) {try {Thread.sleep(500);System.out.println("name--2"+Thread.currentThread().getName());} catch (InterruptedException e) {e.printStackTrace();}}}});//thread2 startthread2.start();}}

4 锁/同步/synchronized

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种： 
1. 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象； 
2. 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象； 
3. 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象； 
4. 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

    --多线程竞争同一个资源时他们互斥的必须是一个对象(如使用同一个string值)。

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

    --链接http://blog.csdn.net/luoweifu/article/details/46613015

5 synchronized和lock http://blog.csdn.net/XSF50717/article/details/47262717

   synchronized和lock的用法区别
     · synchronized(隐式锁)：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，
        括号中表示需要锁的对象。
     · lock（显示锁）：需要显示指定起始位置和终止位置。一般使用ReentrantLock类做为锁，多个线程中必须要使用一个
        ReentrantLock类做为对象才能保证锁的生效。       且在加锁和解锁处需要通过lock()和unlock()显示指出。
        所以一般会在finally块中写unlock()以防死锁。
  synchronized和lock性能区别
      synchronized是托管给JVM执行的，而lock是java写的控制锁的代码。在Java1.5中，synchronize是性能低效的。
      因为 这是一个重量级操作，需要调用操作接口，导致有可能加锁消耗的系统时间比加锁以外的操作还多。
      相比之下使用Java提供的Lock对象，性能更高一些。但 是到了Java1.6，发生了变化。synchronize在语义上很清晰，
      可以进行很多优化，有适应自旋，锁消除，锁粗化，轻量级锁，偏向锁等等。
      导致 在Java1.6上synchronize的性能并不比Lock差。
  synchronized和lock机制区别
    · synchronized原始采用的是CPU悲观锁机制，即线程获得的是独占锁。独占锁意味着其 他线程只能依靠阻塞来等待线程释放锁。
    · Lock用的是乐观锁方式。所谓乐观锁就是，每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，
       直到成功为止。乐观锁实现的机制就是CAS操作Compare and Swap）。