Java线程相关的

参考链接:
https://www.cnblogs.com/wxd0108/p/5479442.html
http://www.runoob.com/java/java-multithreading.html
https://www.cnblogs.com/riskyer/p/3263032.html
线程创建方法:
1\继承Thread类
2\实现Runable接口
4\Callable (有返回值) https://www.cnblogs.com/baizhanshi/p/6425209.html
5\线程池(线程池属于Runable接口)

1\继承Thread类

public class ThreadA extends Thread {
	public void run() {
		try {
			Thread.sleep(1000);
			System.out.println(FulyUtil.getCurrentThreanName() + "----thread");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
			}
}

@Test
	public void TestD() throws Exception {
		ThreadA threadA = new ThreadA();
		threadA.start(); 
		System.out.println(FulyUtil.getCurrentThreanName()+"----MAIN");
		Thread.sleep(3000);
	}

继承Thread类,要实现run()方法.
注意:继承Thread创建的线程是后台线程,主线程结束,后台线程就会自动结束;(后台线程是指在程序运行的时候在后台提供的一种通用服务线程,并且这种线程并不属于程序中不可或缺的部分,参见 java编程思想662页)

2\实现Runable接口:

public class ThreadA implements Runnable {
	@Override
	public void run() {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(FulyUtil.getCurrentThreanName() + "Runable");
	}
}

@Test
	public void TestD() throws Exception {
		ThreadA threadA = new ThreadA();
		new Thread(threadA).start();
		System.out.println(FulyUtil.getCurrentThreanName() +"---main");
		Thread.sleep(3000);
	}

实现Runable接口,也是后台线程;
实现Runable还是要放入Thread中调用start()方法;

3\ 线程池介绍:https://blog.csdn.net/u013276277/article/details/78530322
java提供了四种线程池的实现：
（1）newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
（2）newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。(线程数量固定)
（3）newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
（4）newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
关闭线程池:线程池提供了两个关闭方法，shutdownNow和shuwdown方法。
shutdownNow方法的解释是：线程池拒接收新提交的任务，同时立马关闭线程池，线程池里的任务不再执行。
shutdown方法的解释是：线程池拒接收新提交的任务，同时等待线程池里的任务执行完毕后关闭线程池。

四类线程池类底层都是ThreadPoolExecutor类进行初始化的

public class ThreadA implements Runnable {
	@Override
	public void run() {
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		System.out.println(FulyUtil.getCurrentThreanName() + "Runable");
	}
}

@Test
	public void ThreadPool() throws Exception {
		ExecutorService cachedThreadPool = new ThreadPoolExecutor(10, 20, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
		for (int i = 0; i < 10; i++) {
			cachedThreadPool.execute(new ThreadA());
		}
		System.out.println(FulyUtil.getCurrentThreanName() + "---main");
		Thread.sleep(10000);

	}

corePoolSize:核心池大小，意思是当超过这个范围的时候，就需要将新的线程放到等待队列中了即workQueue；
maximumPoolSize:线程池最大线程数量，表明线程池能创建的最大线程数
keepAlivertime:当活跃线程数大于核心线程数，空闲的多余线程最大存活时间。
unit：存活时间的单位
workQueue:存放任务的队列---阻塞队列 
handler:超出线程范围（maximumPoolSize）和队列容量的任务的处理程序

线程满了?队列满了?(线程满了,放在队列中;队列满了…我没试出来队列满的情况)
参考一下这里: https://blog.csdn.net/u010963948/article/details/80573898

**线程状态:**https://www.cnblogs.com/happy-coder/p/6587092.html
https://blog.csdn.net/pange1991/article/details/53860651/
线程状态通常被分成5中状态:
1\新建(NEW) 2\运行(RUNNABLE 或分为RUNABLE和RUNNING) 3\阻塞(BLOCKED) 4\等待(WAITING)
5\超时等待(TIMED_WAITING) 6\终止(TERMINATED)

初始(NEW)：新创建了一个线程对象，但还没有调用start()方法。
运行(RUNNABLE)：Java线程中将就绪（ready）和运行中（running）两种状态笼统的称为“运行”。
线程对象创建后，其他线程(比如main线程）调用了该对象的start()方法。该状态的线程位于可运行线程池中，等待被线程调度选中，获取CPU的使用权，此时处于就绪状态（ready）。就绪状态的线程在获得CPU时间片后变为运行中状态（running）。
阻塞(BLOCKED)：表示线程阻塞于锁。
等待(WAITING)：进入该状态的线程需要等待其他线程做出一些特定动作（通知或中断）。
超时等待(TIMED_WAITING)：该状态不同于WAITING，它可以在指定的时间后自行返回。
终止(TERMINATED)：表示该线程已经执行完毕。

线程的挂起与阻塞:
https://www.cnblogs.com/hoobey/p/6915638.html
挂起是主动的;阻塞是被动的;

几个Object方法:
1\ Thread.sleep(long millis)，一定是当前线程调用此方法，当前线程进入阻塞，但不释放对象锁，millis后线程自动苏醒进入可运行状态。作用：给其它线程执行机会的最佳方式。
2\ Thread.yield()，一定是当前线程调用此方法，当前线程放弃获取的cpu时间片，由运行状态变会可运行状态，让OS再次选择线程。作用：让相同优先级的线程轮流执行，但并不保证一定会轮流执行。实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。Thread.yield()不会导致阻塞。
3\ t.join()/t.join(long millis)，当前线程里调用其它线程1的join方法，当前线程阻塞，但不释放对象锁，直到线程1执行完毕或者millis时间到，当前线程进入可运行状态。
4\ obj.wait()，当前线程调用对象的wait()方法，当前线程释放对象锁，进入等待队列。依靠notify()/notifyAll()唤醒或者wait(long timeout)timeout时间到自动唤醒。
5\ obj.notify()唤醒在此对象监视器上等待的单个线程，选择是任意性的。notifyAll()唤醒在此对象监视器上等待的所有线程。

猜你喜欢