多线程基础1

1.相关概念

进程：进程指正在运行的程序。

线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，一个进程中至少有一个线程。一个进程中是可以有多个线程的，这个应用程序也可以称之为多线程程序。

总而言之：一个程序运行就是一个进程，一个进程可以有多个线程

什么是多线程？就是一个程序中有多个线程同时执行

 

2.创建线程的两种方式

1. 继承Thread类，并重写Thread的run（）,创建对象，开启线程，run()相当于其他线程的main(),
2. 实现Runnable接口，并实现run（），创建Runnable接口的子类对象，作为参数传入到某个线程的构造方法钟，，开启线程

 

      2.1Extends Thread 创建线程

//自定义线程类
class ThreadDemo2 extends Thread{
	
	//构造方法
	public ThreadDemo2 (String name) {
		//调用父类的String参数的构造方法，指定线程的名称
		super(name);
	}
	
	@Override
	public void run() {
		for (int i = 0; i < 10; i++) {
			//Thread.currentThread().getName()  返回当前正在执行线程的对象的名字
			System.out.println(Thread.currentThread().getName()+"：正在执行！"+i);
		}
	}
	

}

/**
 * 创建测试类
 */
public class test {
	
	public static void main(String[] args) {
		//创建自定义线程对象
		ThreadDemo2 td = new ThreadDemo2("章鱼小丸子");
		ThreadDemo2 td2 = new ThreadDemo2("百变小樱");
		//开启自定义线程
		td.start();
		td2.start();
		
		//在main()方法中执行循环
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程！"+i);
		}
				
	}

}

2.2implements Runnable创建线程

//自定义线程执行任务类
class RunnableDemo1 implements Runnable{
	@Override
	public void run() {		
		for (int i = 0; i < 10; i++) {
			System.out.println("我的线程：正在执行！"+i);
		}
	}
}



//测试类
public class test {
	public static void main(String[] args) {
		//创建自定义线程类对象
		RunnableDemo1 rd = new RunnableDemo1();
		//将Runnable接口的子类对象作为Therad构造的参数传递
		Thread t = new Thread(rd);
		t.start();
		for (int i = 0; i < 10; i++) {
			System.out.println("main线程：正在执行！"+i);
		}		
	}
}

3.线程对象调用run()和调用start()的区别

线程对象调用run()不开启线程，仅是调用对象方法

线程对象调用start()开启线程，并让jvm调用run()在开启的线程中执行

 

主线程的任务在main()中，自定义线程需要执行的任务定义在run()方法中

 

4.Thread类常用方法

5.线程池

线程池是容纳多个线程的容器，其中的线程可以反复使用，省去频繁的创建线程对象的操作，无需反复创建线程而消耗过多资源

class MyRunnable implements Runnable {
	
	public void run() {
	
		System.out.println("我要一个教练");
	
	try {
		Thread.sleep(2000);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	
	System.out.println("教练来了： " +Thread.currentThread().getName());	
	System.out.println("教我游泳,交完后，教练回到了游泳池");	
	}
}

public class ThreadPoolDemo {
	public static void main(String[] args) {
		//创建线程池对象
		ExecutorService service = Executors.newFixedThreadPool(2); //包含2个线程对象
		//创建Runnable实例对象 
		MyRunnable rd = new MyRunnable();
		
		Thread t = new Thread(rd);
		t.start();
		
		//从线程池中获取线程对象,然后调用MyRunnable中的run()
		service.submit(rd);
		//再获取个线程对象，调用MyRunnable中的run()
		service.submit(rd);
		service.submit(rd);
		
		service.submit(rd);
		//关闭线程池
		service.shutdown();
		
	
	}

}

6.sleep()

Public static native void sleep (long millis) throws InterruptedException

睡眠指定时间，即让该线程休眠millis毫秒再执行，如果时间未到就要醒来需要interrupt()来随时唤醒

7.interrupt()

Public void interrupt ()

唤醒正在睡眠的程序，调用interrupt()，会使得sleep()方法抛出InterruptedException，当sleep()抛出了异常就中断了sleep()，从而让程序继续运行下去

8.wait(),notify(),notifyAll()

wait: 让线程进入等待阻塞状态，会一直等到它被其他线程调用notify()或者notifyAll()唤醒，该方法只能在同步方法中调用，如果当前线程不是锁的持有者，该方法抛出一个illeagalMonitorStateException

wait(long timeout ) :时间到了自动执行，类似sleep(long millis)

notify() 该方法只能在方法和同步代码块内部调用，随机选择一个再对该对象调用wait()解除阻塞状态

notifyAll() 唤醒所有wait了的对象

wait(),notify(),notifyAll() 必须写在synchronized方法内部，或者synchronized块内部

9.多线程的安全问题

两个线程共享了数据，如果多个线程不涉及数据共享，各自执行自己的代码，就不会出现线程安全问题，在线程不安全的单例模式中，就会出现该问题

public class ThreadDemo {
    public static void main(String[] args) {
        System.out.println("当前线程：" + Thread.currentThread().getName());
        Dog dog = new Dog();
       
        Thread thread1 = new Thread(dog);
        Thread thread2 = new Thread(dog,"百变小樱");
        thread2.start();
        thread1.start();
        

    }
}
class Dog implements Runnable {
    // 定义线程共享数据
    private int t = 100;

    @Override
    public void run() {
        // TODO：死循环，暂不处理
        while (true) {
            if (t > 0) {
            	try {
					Thread.sleep(100);
					 System.out.println("当前线程：" + Thread.currentThread().getName() + "---" + t--);
				} catch (InterruptedException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}              
            }
        }
    }
}

 

会出现不符合程序原意的输出

 

9.1产生的原因：1.多个线程共享了数据2.在线程任务中设计了对共享数据的操作（这个操作是判断t>0，执行t--），一个线程在操作共享数据的时候，其他线程也操作了共享数据

 

线程的安全问题多是由全局变量和静态变量引起的，当多个线程对共享数据只执行读操作是，线程一般是安全的，当多个线程执行写操作时，需要考虑同步来解决线程安全问题。

 

9.2解决思路

将操作共享数据的代码作为一个整体，同一时间只允许一个线程执行，执行过程中其他线程不能参与执行

synchronized (expression){

// 需要同步的代码

//expression必须是一个引用型变量

}

 

  public void run() {
        // TODO：使用同步代码块解决线程不安全问题 
        while (true) {
        	synchronized (this) {
        		if (t > 0) {
                	try {
    					Thread.sleep(100);
    					 System.out.println("当前线程：" + Thread.currentThread().getName() + "---" + t--);
    				} catch (InterruptedException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}                
                }
			}
        }
    }