学步园

一、操作系统中线程和进程的概念

  进程是指一个内存中运行的应用程序，每个进程都有自己独立的一块内存空间，一个进程中可以启动多个线程。比如在Windows系统中，一个运行的exe就是一个进程。

二、Java中的线程

 java线程：创建与启动

一，  定义线程

public void run()；
如果该线程是使用独立的 Runnable 运行对象构造的，则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。 
Thread 的子类应该重写该方法。
2、实现Runnable接口。

package bbs.itheima.com;

public class ThreadIntDemo {

	/**
	 * 线程的创建方法
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
       /**使用匿名内部类创建线程*/
		Thread t1 = new Thread(){//继承Thread类
			public void run(){
				System.out.println("匿名内部类");
			}
		};
		t1.start();
		
		//使用runnable 接口创建线程
		//实现Runnable接口
		Runnable runner = new Runnable(){

			@Override
			public void run() {
				// TODO Auto-generated method stub
				System.out.println("实现Runnable接口");
			}
			
		};
		//在创建线程的时候，将Runnerble实例作为构造参数
		Thread t2 = new Thread(runner);
		t2.start();
		
		//使用Runnable接口创建匿名类，创建线程实例
		Thread t3 = new Thread(new Runnable(){
			public void run(){
				System.out.println("Hi t3");
			}
		});
		t3.start();
		
		//创建匿名内部类，直接启动线程
		new Thread(){
			public void run(){
				System.out.println("HI Thread");
			}
		};
		//创建匿名类实例，使用Runnable接口
		new Thread(new Runnable(){
			public void run(){
				System.out.println("HI, Runnable");
			}
		}).start();
	}

}

package bbs.itheima.com;

public class ThreadDemo {
   /**基本基本线程演示*/
	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Person p = new Person();//p线程实例
      Person2 p2 = new Person2();//p2线程实例
      p.start();
      p2.start();
      System.out.println("over");
	}

}
class Person extends Thread{
	public void run(){
		for(int i = 0;i<5;i++){
			System.out.println("我是谁？");
		}
	}
}
class Person2 extends Thread{
	public void run(){
		for(int i = 0;i<5;i++){
			System.out.println("张三");
		}
	}
}

注：
1) new运算创建线程后，线程迚入New状态（初始状态）
2) 调用 start()方法后，线程从New状态迚入Runnable状态（就绪状态）
 start()方法是在main()方法（Running状态）中调用的
3) 线程结束后，迚入Dead状态（死亡状态），被对象垃圾回收
4) main()方法结束后，其它线程，比如上例中p1和p2开始抢着迚入Running状态
由谁抢到是底层操作系统决定（操作系统分配时间片）
 单核处理器：在一个时间点上只有一个线程在Running状态；双核处理器：2个
如果p1迚入Running状态，当操作系统分配给它的时间片到期时，p1迚入Runnable状态，p2迚入Running状态
 在期间有可能其它的迚程的线程获得时间片，那么p1和p2同时迚入Runnable状态，等待操作系统分配时间片
5) 线程迚入Dead状态后，只能被垃圾回收，丌能再开始
6) 如果线程在运行过程中，自己调用了yield()方法，则主劢由Running状态迚入Runnable状态

二，线程状态管理

1) 让出CPU Thread.yield()
当前线程让出处理器（离开Running状态），使当前线程迚入Runnable状态等待
2) 休眠 Thread.sleep(times)
  使当前线程从 Running 放弃处理器迚入Block状态, 休眠times毫秒, 再返回到Runnable 如果其他线程打断当前线程的Block(sleep),   就   会収生InterruptedException。
   Thread.yield()方法演示

package bbs.itheima.com;

public class ThreadDemo {
   /**基本基本线程演示*/
	public static void main(String[] args) {
		// TODO Auto-generated method stub
      Person p = new Person();//p线程实例
      Person2 p2 = new Person2();//p2线程实例
      p.start();
      p2.start();
      System.out.println("over");
	}

}
class Person extends Thread{
	public void run(){
		for(int i = 0;i<155;i++){
			System.out.println("我是谁？");
			Thread.yield();
		}
	}
}
class Person2 extends Thread{
	public void run(){
		for(int i = 0;i<155;i++){
			System.out.println("张三");
			Thread.yield();
		}
	}
}

线程的常用属性及方法

1) 线程的优先级 (资源紧张时候, 尽可能优先)
 t3.setPriority(Thread.MAX_PRIORITY); 设置为最高优先级
 默认有10 优先级, 优先级高的线程获得执行（迚入Running状态）的机会多. 机会的多少丌能通过代码干预
 默认的优先级是 5
2) 后台线程（守护线程，精灵线程）
 t1.setDaemon(true);
 Java迚程的结束：当前所有前台线程都结束时, Java迚程结束
 当前台线程结束时， 丌管后台线程是否结束, 都要被停掉!
3) 获得线程名字
getName()
4) 获得当前线程
Thread main = Thread.currentThread();

Sleep状态的打断唤醒

 1) Thread.sleep(times)
使当前线程从 Running状态放弃处理器，迚入Block状态, 休眠times（单位为毫秒）, 休眠结束后，再返回到Runnable状态
2) interrupt() 方法打断/中断
使用该方法可以让一个线程提前唤醒另外一个sleep Block的线程
3) 被唤醒线程会出现中断异常
   
package bbs.itheima.com;

public class SleepDemo {

	/**
	 * Sleep(休眠）演示
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Thread t = new Thread(){
			public void run(){//覆盖run（）方法
				long start = System.currentTimeMillis();
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
				long end = System.currentTimeMillis();
				System.out.println("线程t休眠了"+(end-start));
				System.out.println("线程t结束了");
			}
		};
      t.start();
      System.out.println("main结束");
	}

}



main结束
线程t休眠了1000
线程t结束了

线程的同步与锁

一、同步问题提出

线程的同步是为了防止多个线程访问一个数据对象时，对数据造成的破坏。

例如：两个线程ThreadA、ThreadB都操作同一个对象Foo对象，并修改Foo对象上的数据。

public class Foo {
    private int x = 50;

    public int getX() {
        return x;
    }

    public int fix(int y) {
        x = x - y;
        return x;
    }
}

public class MyRunnable implements Runnable {
    private Foo foo = new Foo();

    public static void main(String[] args) {
        MyRunnable r = new MyRunnable();
        Thread ta = new Thread(r, "Thread-A");
        Thread tb = new Thread(r, "Thread-B");
        ta.start();
        tb.start();
    }

    public void run() {
        for (int i = 0; i < 3; i++) {
            this.fix(30);
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " : 当前foo对象的x值= " + foo.getX());
        }
    }

    public int fix(int y) {
        return foo.fix(y);
    }
}
 

Thread-B : 当前foo对象的x值= -10
Thread-B : 当前foo对象的x值= -40
Thread-A : 当前foo对象的x值= -70
Thread-B : 当前foo对象的x值= -70
Thread-A : 当前foo对象的x值= -100
Thread-A : 当前foo对象的x值= -130

从结果发现，这样的输出值明显是不合理的。原因是两个线程不加控制的访问Foo对象并修改其数据所致。

 如果要保持结果的合理性，只需要达到一个目的，就是将对Foo的访问加以限制，每次只能有一个线程在访问。这样就能保证Foo对象中数据的合理性了。

 在具体的Java代码中需要完成一下两个操作：

把竞争访问的资源类Foo变量x标识为private；

同步哪些修改变量的代码，使用synchronized关键字同步方法或代码

二、同步和锁定

        1、锁的原理