java 线程什么意思？Java多线程是什么意思
各位老铁们好，相信很多人对java 线程什么意思都不是特别的了解，因此呢，今天就来为大家分享下关于java 线程什么意思以及Java多线程是什么意思的问题知识，还望可以帮助大家，解决大家的一些困惑，下面一起来看看吧！
Java中,线程是什么意思,多线程又是什么
在计算机中当一个程序运行的时候就会创建至少一个进程，例如当我们运行QQ的时候，系统就会创建进程来处理我们平时的一些操作，当我们打开任务管理器的时候，在进程的列表里面就可以找到QQ.exe的运行程序;
在计算机中处理进程之外还有另一个概念就是线程，线程是存在于进程当中，一个进程可以包含多个线程;当我们的计算机有多核处理器的时候，使用多线程可以加快程序的运算速率;如果一个进程中只有一个线程，当程序遇到一个比较耗时的计算的时候，由于程序是单线程的，那么程序只能等待这个运算结束的时候再继续运行，这样会大大的降低程序的效率;当时用多个线程的时候，在某个线程遇到比较耗时的运算的时候，该线程可以继续自己的运算，但是其他的线程也可以同步进行，这样当耗时的计算结束之后，其他线程也将自己所需要的东西执行完毕，这样就会很大的提高程序执行效率;
在程序运行中对于文件的保存相对于处理器的运算速度来说是很慢的，当我们程序中接收到一个保存文件的信息之后，我们可以创建一个保存文件的线程，在主线程中我们可以继续进行我们的其他运算，这样当文件保存好之后，我们的其他运算也会完成，互不影响;
在Java中我们可以创建一个自己的类继承于Thread类，并且重写run()方法，当线程启动之后，run()方法里面的操作都在线程中进行处理，而不会影响主线程的信息;
当我们创建好一个自定义线程类之后，我们可以创建这个自定义线程的对象，进行线程的启动;线程须调用start();方法进行启动，这样run()方法里面的内容才会在线程中运行;如果我们不去调用start()方法，那我们只是创建了一个普通的类，即使我们手动调用run()方法，run()方法里面的内容也不会在线程中运行;
在Java中线程主要有初始状态，运行状态，阻塞状态，终止状态等;当我们新创建一个线程对象的时候，此时线程的状态为初始状态;当我们调用start()之后，此时的线程才被激活成为运行状态，之后run()方法里面的信息才会在子线程中运行;我们可以在不同的阶段调用不同的方法将线程设置为不同的状态;比如有时候我们的操作需要等待其他线程中运算结束之后才可以继续进行，这时候我们就可以将线程设置为等待状态，当需要的资源满足条件之后，可以继续运行当前的线程;
以上的内容就是关于Java中线程是什么，更多关于Java方面的问题可以看下这个视频教程：网页链接，希望我的回答能帮到你。
Java线程的概念与原理
一操作系统中线程和进程的概念
现在的操作系统是多任务操作系统多线程是实现多任务的一种方式
进程是指一个内存中运行的应用程序每个进程都有自己独立的一块内存空间一个进程中可以启动多个线程比如在Windows系统中一个运行的exe就是一个进程线程是指进程中的一个执行流程一个进程中可以运行多个线程比如java exe进程中可以运行很多线程线程总是属于某个进程进程中的多个线程共享进程的内存同时执行是人的感觉在线程之间实际上轮换执行
二 Java中的线程
在Java中线程指两件不同的事情
java lang Thread类的一个实例
线程的执行
使用java lang Thread类或者java lang Runnable接口编写代码来定义实例化和启动新线程一个Thread类实例只是一个对象像Java中的任何其他对象一样具有变量和方法生死于堆上 Java中每个线程都有一个调用栈即使不在程序中创建任何新的线程线程也在后台运行着一个Java应用总是从main()方法开始运行 mian()方法运行在一个线程内它被称为主线程一旦创建一个新的线程就产生一个新的调用栈线程总体分两类用户线程和守候线程
当所有用户线程执行完毕的时候 JVM自动关闭但是守候线程却不独立于JVM守候线程一般是由操作系统或者用户自己创建的
———————————MultiT java——————————————————————
class MultiThread
{
public static void main(String[] args)
{
MyThread mt=new MyThread();
//mt setDaemon(true);//设定为后台线程 main进程结束时后台进程也跟着结束
//mt setPriority(Thread MAX_PRIORITY);//设定线程优先级 MAX_PRIORITY为 MIN_PRIORITY为 NORM_PRIORITY为
//设定为最高优先级后程序运行时 mt线程一直运行强制终止时 main线程才运行
//设定为最高优先级的线程无论有无yield();线程总一直运行直到强制终止时 main和mt线程交替运行
mt start();
int index=;
while(true)//显示结果与教程不同
{
if(index++==)
break;
System out println( main:+Thread currentThread() getName());//获取线程名字
}
}
}
class MyThread extends Thread
{
public void run()
{
while(true)
{
System out println(getName());
yield();//允许当前线程停止转去执行其他线程静态方法
//mt进程执行时切换到main进程 main进程执行一段时间后
//切换进程到mt mt执行完获取名字后返回到main进程
}
}
}
//一个长时间处于等待状态的线程也有可能被线程调度器调度从而运行
//打破高优先级线程始终获有运行时间的状态
——————————————————————————————————————
——————————MultiThread java———————————————————————
class MultiThread
{
public static void main(String[] args)
{
MyThread mt=new MyThread();
//new Thread(mt) start();//创建多个同样的线程访问同一个变量index若MyThread采用继承Thread方式则无法共享同一个变量
//new Thread(mt) start();
//new Thread(mt) start();
//new Thread(mt) start();
mt getThread() start();//也可以采用内部类的方式共享访问同一个变量
mt getThread() start();
mt getThread() start();
mt getThread() start();
//mt setDaemon(true);//设定为后台线程 main进程结束时后台进程也跟着结束
//mt setPriority(Thread MAX_PRIORITY);//设定线程优先级 MAX_PRIORITY为 MIN_PRIORITY为 NORM_PRIORITY为
//设定为最高优先级后程序运行时 mt线程一直运行强制终止时 main线程才运行
//设定为最高优先级的线程无论有无yield();线程总一直运行直到强制终止时 main和mt线程交替运行
//mt start();
int index=;
while(true)//显示结果与教程不同
{
// if(index++==)
// break;
System out println( main:+Thread currentThread() getName());//获取线程名字
}
}
}
class MyThread//implements Runnable//extends Thread//使用外部类的方式
//使用内部类完成使用Runnable接口才能完成的两个功能 a创建多个线程 b访问同一个变量
{
int index=;
private class InnerThread extends Thread//不想让外部访问其实现方法加上private
{
public void run()
{
while(true)
{
System out println(Thread currentThread() getName()+:+index++);
}
}
}
Thread getThread()
{
return new InnerThread();
}
/*
public void run()
{
while(true)
{
System out println(Thread currentThread() getName()+:+index++);
//yield();//允许当前线程停止转去执行其他线程静态方法
//mt进程执行时切换到main进程 main进程执行一段时间后
//切换进程到mt mt执行完获取名字后返回到main进程
}
}
*/
}
//一个长时间处于等待状态的线程也有可能被线程调度器调度从而运行
//打破高优先级线程始终获有运行时间的状态
//如果不需要修改Thread类的除了run方法外的其他方法选用implements Runnable
———————————————————————————————————————
———————————TicketsSystem java———————————————————
//多线程实现火车票的售票系统用同步块或著同步方法
class TicketsSystem
{
public static void main(String[] args)//运行结果与教程中不同不完全顺序每次运行顺序都不完全一样
{
SellThread st=new SellThread();//创建四个线程访问同一变量tickets
//错 SellThread st=new SellThread();//若采用创建四个对象的方式则每个对象中都有张票
new Thread(st) start();//b为false用的同步方法|//同步方法与同步块共用中显示的是只调用了同步块而同步方法未被调用
//b为true用的同步块|//原因启动第一个线程后 CPU时间片没有到期线程没有立即运行接着执行b=true
//|//解决办法启动第一个线程后执行一个睡眠时间让CPU时间片到期
try
{
Thread sleep();
}
catch(Exception e)
{
e printStackTrace();
}
st b=true;
new Thread(st) start();
//new Thread(st) start();
//new Thread(st) start();
}
}
class SellThread implements Runnable//程序有点小问题当剩下最后一张票时四个线程都运行可能会出现票数为（系统长时间运行时）
//可加上一个静态方法sleep();它会抛出异常
{
int tickets=;
//Object obj=new Object();//也可以声明一个Thread对象
Thread th=new Thread();
boolean b=false;
public void run()
{
if(b==false)
{
while(true)
sell();
}
else
{
while(true)
{//同步方法利用的是this所代表的对象的锁
synchronized(this)//采用同步后显示正确此方法两步声明Thread对象用synchronized把原方法括起来
{//这里换th为this
///*
if(tickets>)
{
try
{
Thread sleep();
}
catch(Exception e)
{
e printStackTrace();
}
System out println( th+Thread currentThread() getName()+ sell tickets:+tickets);
tickets;
}
//*/
}
}
}
}
public synchronized void sell()//每个class也有一个锁是这个class所对应的class对象的锁（监视器）
{
if(tickets>)
{
try
{
Thread sleep();
}
catch(Exception e)
{
e printStackTrace();
}
System out println( sell+Thread currentThread() getName()+ sell tickets:+tickets);
tickets;
}
}
}
————————————————————————————————————————
———————————TestWN java————————————————————
class Test
{
public static void main(String[] args)
{
Queue q=new Queue();
Producer p=new Producer(q);
Consumer c=new Consumer(q);
p start();
c start();
}
}
class Producer extends Thread
{
Queue q;
Producer(Queue q)
{
this q=q;
}
public void run()
{
for(int i=;i<;i++)
{
q put(i);
System out println( Producer put:+i);
}
}
}
class Consumer extends Thread
{
Queue q;
Consumer(Queue q)
{
this q=q;
}
public void run()
{
while(true)
{
System out println( Consumer get:+q get());
}
}
}
class Queue//wait notify方法必须用在同步方法中要加上关键字synchronized
{
int value;
boolean bFull=false;
public synchronized void put(int i)
{
if(!bFull)
{
value=i;
bFull=true;
notify();
}
try
{
wait();
}
catch(Exception e)
{
e printStackTrace();
}
}
public synchronized int get()
{
if(!bFull)
{
try
{
wait();
}
catch(Exception e)
{
e printStackTrace();
}
}
bFull=false;
notify();
return value;
}
}
————————————————————————————————————
————————————TestThread java———————————————————————
class TestThread
{
public static void main(String[] args)
{
Thread t=new Thread();
t start();
int index=;
while(true)
{
if(index++==)
{
t stopThread();
t interrupt();//让线程终止
break;
}
System out println(Thread currentThread() getName());
}
System out println( main() exit);
}
}
class Thread extends Thread
{
private boolean bStop=false;
public synchronized void run()
{
while(!bStop)
{
try
{
wait();//加入wait后 main线程结束时程序还未终止原因是Thread的线程调用wait方法进入对象的等待队列中需要notify方法将它唤醒
}
catch(Exception e)
{
//e printStackTrace();
if(bStop)
return;
}
System out println(getName());
}
}
public void stopThread()
{
bStop=true;
}
}
lishixinzhi/Article/program/Java/gj/201311/27407Java多线程是什么意思
Java多线程实现方式主要有三种：继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。其中前两种方式线程执行完后都没有返回值，只有最后一种是带返回值的。
1、继承Thread类实现多线程
继承Thread类的方法尽管被我列为一种多线程实现方式，但Thread本质上也是实现了Runnable接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法，它将启动一个新线程，并执行run()方法。这种方式实现多线程很简单，通过自己的类直接extend Thread，并复写run()方法，就可以启动新线程并执行自己定义的run()方法。例如：
在合适的地方启动线程如下：
2、实现Runnable接口方式实现多线程
如果自己的类已经extends另一个类，就无法直接extends Thread，此时，必须实现一个Runnable接口，如下：
为了启动MyThread，需要首先实例化一个Thread，并传入自己的MyThread实例：
事实上，当传入一个Runnable target参数给Thread后，Thread的run()方法就会调用target.run()，参考JDK源代码：
3、使用ExecutorService、Callable、Future实现有返回结果的多线程
ExecutorService、Callable、Future这个对象实际上都是属于Executor框架中的功能类。想要详细了解Executor框架的可以访问http://www.javaeye.com/topic/366591，这里面对该框架做了很详细的解释。返回结果的线程是在JDK1.5中引入的新特征，确实很实用，有了这种特征我就不需要再为了得到返回值而大费周折了，而且即便实现了也可能漏洞百出。
可返回值的任务必须实现Callable接口，类似的，无返回值的任务必须Runnable接口。执行Callable任务后，可以获取一个Future的对象，在该对象上调用get就可以获取到Callable任务返回的Object了，再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。下面提供了一个完整的有返回结果的多线程测试例子，在JDK1.5下验证过没问题可以直接使用。代码如下：
代码说明：
上述代码中Executors类，提供了一系列工厂方法用于创先线程池，返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads)
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool()
创建一个可缓存的线程池，调用execute将重用以前构造的线程（如果线程可用）。如果现有线程没有可用的，则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor()
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
创建一个支持定时及周期性的任务执行的线程池，多数情况下可用来替代Timer类。
总结：ExecutoreService提供了submit()方法，传递一个Callable，或Runnable，返回Future。如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。
好了，文章到这里就结束啦，如果本次分享的java 线程什么意思和Java多线程是什么意思问题对您有所帮助，还望关注下本站哦！