java多線程編程

Ⅰ 《java多線程編程核心技術》和《java並發編程的藝術》兩本書的異同

區別很大：

《java多線程編程核心技術》：
這本書讓你入個門，整體上了介紹一些並發編程的基本API、常見場景和一些坑，推薦先看這本書，比較簡單，適合新手，但是原理不夠深入
和《java並發編程的藝術》
這本書從底層和實現原理開始講起，深入java內存模型和處理器的知識講解並發編程的實現原理，適合有一定基礎的人看

Ⅱ Java多線程編程的好處是什麼

多線程變成好處：

1. 資源利用率更好

2. 

   詳細請見：http://ifeve.com/benefits/

   Ⅲ JAVA多線程編程的幾種表示方法

   創建線程有兩種方法：繼承Thread類和實現Runnable介面。
   
   方法一：繼承 Thread 類，覆蓋方法 run()，我們在創建的 Thread 類的子類中重寫 run() ,加入線程所要執行的代碼即可。下面是一個例子：
   public class MyThread extends Thread {
   int count= 1, number;
   public MyThread(int num) {
   number = num;
   System.out.println("創建線程 " + number);
   }
   public void run() {
   while(true) {
   System.out.println("線程 " + number + ":計數 " + count);
   if(++count== 6) return;
   }
   }
   public static void main(String args[]) {
   for(int i = 0; i < 5; i++) new MyThread(i+1).start();
   }
   }
   
   方法二：實現 Runnable 介面
   Runnable 介面只有一個方法 run()，我們聲明自己的類實現 Runnable 介面並提供這一方法，將我們的線程代碼寫入其中，就完成了這一部分的任務。但是 Runnable 介面並沒有任何對線程的支持，我們還必須創建 Thread 類的實例，這一點通過 Thread 類的構造函數public Thread(Runnable target);來實現。下面是一個例子：
   public class MyThread implements Runnable {
   int count= 1, number;
   public MyThread(int num) {
   number = num;
   System.out.println("創建線程 " + number);
   }
   public void run() {
   while(true) {
   System.out.println("線程 " + number + ":計數 " + count);
   if(++count== 6) return;
   }
   }
   public static void main(String args[]) {
   for(int i = 0; i < 5; i++) new Thread(new MyThread(i+1)).start();
   }
   }
   兩種方法各有千秋，可以靈活運用。

   Ⅳ 什麼是Java多線程編程

   一、 什麼是多線程：

   我們現在所使用操作系統都是多任務操作系統(早期使用的DOS操作系統為單任務操作系統)，多任務操作指在同一時刻可以同時做多件事(可以同時執行多個程序)。

   • 多進程:每個程序都是一個進程，在操作系統中可以同時執行多個程序,多進程的目的是為了有效的使用CPU資源，每開一個進程系統要為該進程分配相關的系統資源(內存資源)

   • 多線程:線程是進程內部比進程更小的執行單元(執行流|程序片段),每個線程完成一個任務,每個進程內部包含了多個線程每個線程做自己的事情，在進程中的所有線程共享該進程的資源；

   • 主線程:在進程中至少存在一個主線程，其他子線程都由主線程開啟,主線程不一定在其他線程結束後結束，有可能在其他線程結束前結束。Java中的主線程是main線程,是Java的main函數;

   二、 Java中實現多線程的方式:

   • 繼承Thread類來實現多線程:

   當我們自定義的類繼承Thread類後，該類就為一個線程類,該類為一個獨立的執行單元，線程代碼必須編寫在run()方法中,run方法是由Thread類定義，我們自己寫的線程類必須重寫run方法。

   run方法中定義的代碼為線程代碼，但run方法不能直接調用，如果直接調用並沒有開啟新的線程而是將run方法交給調用的線程執行

   要開啟新的線程需要調用Thread類的start()方法，該方法自動開啟一個新的線程並自動執行run方法中的內容

   

   java多線程的啟動順序不一定是線程執行的順序，各個線程之間是搶佔CPU資源執行的，所有有可能出現與啟動順序不一致的情況。

   CPU的調用策略：

   如何使用CPU資源是由操作系統來決定的，但操作系統只能決定CPU的使用策略不能控制實際獲得CPU執行權的程序。

   線程執行有兩種方式：

   1.搶占式：

   目前PC機中使用最多的一種方式，線程搶佔CPU的執行權，當一個線程搶到CPU的資源後並不是一直執行到此線程執行結束，而是執行一個時間片後讓出CPU資源，此時同其他線程再次搶佔CPU資源獲得執行權。

   2.輪循式;

   每個線程執行固定的時間片後讓出CPU資源，以此循環執行每個線程執行相同的時間片後讓出CPU資源交給下一個線程執行。

   希望對您有所幫助！~

   Ⅳ java多線程編程

   樓主出現問題有2點：
   1. wake() 這個方法也要同步啊，加關鍵字synchronized ；
   2. 第一次調用st（）方法後，available應該保持不變，這樣才能保證線程b也列印..start，所以加個if判斷一下就ok啦。
   
   public class ABC {
   
   boolean available=false;
   String name;
   int count=0;
   public ABC(String name){
   this.name=name;
   }
   public synchronized void st(){
   System.out.println("... start.");
   count++;
   if(count>1){
   available=true;
   }
   try{
   wait();
   }catch(Exception e){}
   System.out.println("... end.");
   }
   public synchronized void end(){
   System.out.println("... end.");
   }
   public synchronized void wake() {
   notifyAll();
   }
   
   public static void main(String[] args) {
   // TODO Auto-generated method stub
   ABC x=new ABC("haha");
   TestThread a=new TestThread(x);
   TestThread b=new TestThread(x);
   C c=new C(x);
   (new Thread(a)).start();
   (new Thread(b)).start();
   (new Thread(c)).start();
   }
   }
   class TestThread implements Runnable{
   ABC abc;
   public TestThread(ABC abc){
   this.abc=abc;
   }
   public void run(){
   if(!abc.available){
   abc.st();
   }
   else abc.end();
   
   }
   }
   class C implements Runnable{
   ABC abc;
   public C(ABC abc){
   this.abc=abc;
   }
   public void run(){
   try{
   Thread.sleep(1000);
   // System.out.println("sjlfsj jfsdl j"); //驗證是否執行到這里
   }catch(InterruptedException e){};
   abc.wake();
   }
   }

   Ⅵ JAVA多線程編程求教

   代碼就不給了，給你個思路，用一個線程刷新標簽的顏色，再設置一個變數判斷是否執行（比如boolean run=true），點擊按鈕後變數設置run為false，再點一下又變回true，這樣就可以了，思路有了應該好做了，樓主加油

   Ⅶ java多線程編程小題

   我有個java多線程的問題，向你請教，題目如下：編寫一個多線程程序實現如下第一次調用st（）方法後，available應該保持不變，這樣才能保證線程b也列印.v

   Ⅷ 求JAVA多線程編程代碼

   測試過了，沒問題。基本思路，實例化一個橋類，誰得到橋的可用標志誰過橋。
   我第一個看到這個100分的，說實話，知道你是個學生要代碼而已，線程類好久沒練手了，練習一下而已，否則真不會給你寫代碼。因為我讀書的時候也發過類似的求助，知道什麼感受。不懂的時候真的沒辦法，所以告訴你思路。
   package cn.thread;
   
   public class Through_out_bridge {
   
   public static void main(String[] args) {
   Bridge b = Bridge.getInstance();//實例化橋
   //實例化左端9個人，此時所有人都不能過橋，橋的可以狀態標志為不可以用
   for (int i = 1; i <= 9; i++) {
   Thread t = new Thread(new Person(false, i, b));
   t.start();
   }
   //實例化右端12個人，此時所有人都不能過橋，橋的可以狀態標志為不可以用
   for( int i=1 ;i<=12;i++)
   {
   Thread t = new Thread(new Person(true,i,b));
   t.start();
   }
   //橋的可用狀態給左端第10個人，可以自定義給誰
   b.state = true;
   Thread t = new Thread(new Person(false, 10, b));
   }
   
   }
   
   class Person implements Runnable {
   
   public Bridge bridge;//橋
   private String hand;//在橋哪一端
   int No;//序號
   
   public Person(boolean side, int i, Bridge bridge) {
   
   this.No = i;
   this.bridge = bridge;
   if(bridge.state)
   {
   System.out.println(i+"已經過橋。");
   }
   if (side) {
   this.hand = new String("右");
   } else {
   this.hand = new String("左");
   }
   }
   
   //過橋方法
   public synchronized void through() throws InterruptedException {
   
   if (bridge.state) {
   System.out.println(hand+"邊第"+No + "在過橋");
   bridge.open( No);
   } else {
   bridge.lock(No);
   
   }
   }
   
   public void run() {
   try {
   Thread.sleep(1000);
   // System.out.println(No+hand+" 邊已經過橋!");
   through();
   } catch (InterruptedException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
   }
   }
   }
   
   class Bridge {
   //可用狀態判斷true：可用
   public boolean state = false;
   //自行實例化
   public static Bridge getInstance() {
   return new Bridge();
   }
   
   public synchronized void open(int i) throws InterruptedException {
   if (state) {
   Thread.sleep(1000);
   this.state=true;
   notify();
   }
   }
   
   public synchronized void lock(int i) throws InterruptedException {
   if (!state) {
   this.state=false;
   System.out.println(i + " 在等待.");
   wait();
   }
   }
   }

   Ⅸ java多線程網路編程

   將所有處理動作寫成Thread
   假如:ServerSenderThread是伺服器的發送線程
   ServerAccepterThread是伺服器的接受線程
   ClientSenderThread是客戶端發送線程
   ClientAccepterThread是客戶端接受線程
   並在 ServerAccepterThread 中寫一個方法，當接受到"exit"字元串，就結束線程

   Ⅹ java多線程編程問題

   線程同步問題，好解決