查询百度大致可以理解为一段具有独立功能的程序，线程是程序中每个部分的代码，一个进程，拥有多个线程，或者子进程。windows 下exe程序就是一个进程。
线程：
线程是进程在相同时间分个每个客户单独运行的一段相同程序代码，多线程指的是在程序中同时运行的多个方法片段。
多线程的理解：
一个类如果实现了Runnable接口或者继承了Thread类，那么它就是一个多线程类，如果是要实现多线程，还需要重写run()方法，所以run() 方法是多线程的入口
但是在启动多线程的时候，不是从run()方法开始的，而是从start()开始的 理由是：当执行多线程的时候，每一个线程会抢占资源，而操作系统会为其分配资源，在start()方法中不仅执行了多线程的代码，除此还调用了一个start0()方法，该方法的声明是native,在Java语言中用一种技术叫做JNI，即JavaNativeInterface，该技术特点是使用Java调用本机操作系统提供的函数，但是有一个缺点是不能离开特定的操作系统，如果线程需要执行，必须有操作系统去分配资源，所以此操作主要是JVM根据不同的操作系统来实现的
如果多线程是通过实现Runnable接口来实现的，那么与通过继承Thread来实现有一个区别，那就是多线程的启动方式——必须是通过start()来启动，但是Runnable接口只有一个方法，并没有start()方法，所以在启动多线程的时候必须调用Thread类的一个构造方法——Thread(Runnable target),该构造方法得到了Runnable接口的一个实现，于是就可以调用Thread类的start()方法了。
线程的实现方式：大致3种
1第一种继承thread：
package com.zk.study.thread;
public class ThreadTest extends Thread {
private String name;
public ThreadTest() {
super();
}
public ThreadTest(String name) {
super();
this.name = name;
}
@Override
public void run() {
for(int i=0;i<20;i++){
System.out.println(name+":"+i);
}
}
}
2第二种实现runnable接口
package com.zk.study.thread;
public class ThreadsconedTest implements Runnable{
private String name;
@Override
public void run() {
for(int i=0;i<20;i++){
System.out.println(name+":"+i);
}
}
public ThreadsconedTest() {
super();
}
public ThreadsconedTest(String name) {
super();
this.name = name;
}
}
3 第三种 实现Callable
package com.zk.study.thread;
import java.util.concurrent.Callable;
public class ThreadCallable implements Callable<String> {
private String name;
public ThreadCallable(String name) {
super();
this.name = name;
}
public ThreadCallable() {
}
@Override
public String call() throws Exception {
for(int i=0;i<=30;i++){
System.out.println(name+":"+i);
if(i==20){
break;
}
}
return "执行够了，不想执行了"+name;
}
}
主方法，调用线程：
package com.zk.study.thread;
import java.util.concurrent.FutureTask;
public class ThreadDemo {
/**
* @param args
* 线程执行不是通过run方法而是同start方法，run方法是多线程的入口。
*/
/*public static void main(String[] args) {
ThreadTest threadA = new ThreadTest("a");
ThreadTest threadb = new ThreadTest("b");
threadA.run();
threadb.run();
}*/
/**
* 第一种线程实现方式实现并发机制 b:10
a:17
b:11
a:18
* @param args
*/
/*public static void main(String[] args) {
ThreadTest threadA = new ThreadTest("a");
ThreadTest threadb = new ThreadTest("b");
threadA.start();
threadb.start();
}
*/
/**
* 第2种实现runable 多线程并发机制
* B:18
A:17
B:19
A:18
A:19
* @param args
*/
/*public static void main(String[] args) {
ThreadsconedTest test1 = new ThreadsconedTest("A");
ThreadsconedTest test2 = new ThreadsconedTest("B");
Thread t1 = new Thread(test1);
Thread t2 = new Thread(test2);
t1.start();
t2.start();
}
*/
/**
* 实现callable 当我需要执行到某一个时候需要一些返回值得时候
* @param args
*
* 打印结果 A:19
B:19
A:20
B:20
执行够了，不想执行了A
执行够了，不想执行了B
*/
public static void main(String[] args) {
String threadName = null;
ThreadCallable a= new ThreadCallable("A");
ThreadCallable b = new ThreadCallable("B");
FutureTask<String> futureTaska = new FutureTask<String>(a);
FutureTask<String> futureTaskb = new FutureTask<String>(b);
Thread t1 = new Thread(futureTaska);
Thread t2 = new Thread(futureTaskb);
t1.start();
t2.start();
try{
threadName = futureTaska.get();//通过get方法可以获取我们想要的返回值
System.out.println(threadName);
threadName = futureTaskb.get();
System.out.println(threadName);
}catch(Exception e){
e.printStackTrace();
}
}
}
三种方式比较：
1.Thread是Runnable接口的子类，实现Runnable接口的方式解决了Java单继承的局限
2.Runnable接口实现多线程比继承Thread类更加能描述数据共享的概念
3.ThreadCallable需要执行线程时候返回值得时候可以通过这种方式。
目前代码中最好的是实现runnable接口
线程的状态以及运行过程：大致有5种
1 创建状态： 准备好一个多线程对象 new thread
2 就绪状态： 调用了start（）方法，等待cpu进行调度,分配资源
3 运行状态： 执行run方法，执行线程完成方法任务。
4 阻塞状态： 暂停执行，可能将资源交给其他线程使用
5 终止状态： 线程销毁
线程的常用方法
1 取得线程的名称 getName()
2 取得当前线程对象 currentThread()
3 判断线程是否启动 isAlive()
4 线程强行运行 join()
5 线程休眠 sleep()
6 线程的礼让 yield()
7 线程挂起 suspend()
8 线程恢复 resume()
9 线程等待wait()
10 stop()停止线程
一般来说后面不怎么使用，容易造成死锁
package com.zk.study.thread;
class RunnableDemo implements Runnable{
private String name;
public RunnableDemo(String name) {
super();
this.name = name;
}
@Override
public void run() {
for(int i=0;i<20;i++){
//System.out.println("当前线程对象："+Thread.currentThread().getName());//当前线程名字
/*try {
Thread.sleep(1000);//沉睡一秒 ，
} catch (InterruptedException e) {
e.printStackTrace();
}*/
if(i==10){
System.out.println("礼让");/**
*a:8
a:9
礼让
true
b:0
b:1
*/
Thread.yield();//当一个线程执行到时候，礼让另外一个线程执行。
}
System.out.println(name+":"+i);
}
}
}
public class ThreadCommonMethod {
/**
* 当前线程对象：Thread-1
当前线程对象：Thread-0
当前线程对象：Thread-1
当前线程对象：Thread-0
当前线程对象：Thread-1
当前线程对象：Thread-1
* @param args
*/
public static void main(String[] args) {
RunnableDemo runnableDemo = new RunnableDemo("a");
RunnableDemo runnableDem01 = new RunnableDemo("b");
Thread thread = new Thread(runnableDemo);
Thread thread1 = new Thread(runnableDem01);
System.out.println(thread.isAlive());// 是否执行当中 false
thread.start();
thread1.start();
System.out.println(thread.isAlive());//true
/*for(int i=0;i<=20;i++){
if(i>10){
try {
thread.join();// 强制执行线程thread
// 当主线程执行到大于10的时候强制执行我们的线程，等我们线程执行完在执行主线程
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println("主线程："+i);
}*/
}
}
线程的优先级 能够帮助当前线程首先抢到cpu资源，但不一定每一次一定抢的到，就是第一个运行。
static intMAX_PRIORITY 线程可以具有的最高优先级。默认10
static intMIN_PRIORITY 线程可以具有的最低优先级。默认1
static intNORM_PRIORITY 分配给线程的默认优先级。默认5
同步与死锁：
1 同步代码块 在代码块上加上synchronized 关键字，此代码块就成为同步代码块
2 同步代码块格式
synchronized（同步对象）{
需要同步代码块
}
3 同步的方法 除了代码块可以同步，方法也可以同步。
4 同步方法的格式
synchronized void 方法名称（）{}
package com.zk.study.thread;
public class ThreadSynchronized implements Runnable {
private int ticket =5;
/**
* @param args
*/
public static void main(String[] args) {
ThreadSynchronized threadSynchronized =new ThreadSynchronized();
Thread thread1 = new Thread(threadSynchronized);
Thread thread2 = new Thread(threadSynchronized);
Thread thread3 = new Thread(threadSynchronized);
thread1.start();
thread2.start();
thread3.start();
}
@Override
public void run() {
for(int i=0;i<=10;i++){
/*synchronized (this) {//同步代码块车票：5 车票：4 车票：3 车票：2 车票：1
if(ticket>0){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("车票："+ ticket--);//如果不加同步 就会出现负1 车票：0 车票：-1。资源无法共享，这时候就需要加同步。
}
}*/
tell();
}
}
/**
* 同步方法的执行 5 车票：4 车票：3 车票：2 车票：1
*/
public synchronized void tell(){
if(ticket>0){
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("车票："+ ticket--);//如果不加同步 就会出现负1 车票：0 车票：-1。资源无法共享，这时候就需要加同步。
}
}
}