2. 程式人生 > >kafka 從分割槽任意位置、分割槽開頭、分割槽末尾開始消費資料

kafka 從分割槽任意位置、分割槽開頭、分割槽末尾開始消費資料

阿新 • • 發佈：2019-01-04

最近就kafka消費者消費資料時，消費者提交的offset與同事們有一些分歧和討論，這裡記錄一下自己的研究。

我們知道redis和kafka都可以作為訊息佇列使用，都可以完成釋出訂閱功能，但是kafka相較於redis可以實現訂閱訊息的儲存，可以實現訂閱訊息的任意位置消費，更重要的時kafka訂閱訊息是可以儲存到磁碟上的，而redis訂閱訊息是無法儲存磁碟的。

(1)消費者消費資料時加入一個消費者分組之後，可以通過 subscribe函式訂閱某個topic，這時這個消費者進入brokers的group management管理機制，同一個分片只能被一個分組中的消費者消費，如果同一個分片希望被多個消費者消費，需要將多個消費者放入到不同的消費者分組中。

 //訂閱指定的topic
consumer.subscribe(Arrays.asList(topic));
(2)還有一種消費資料的方式是可以通過assign函式指定要消費的分割槽資料，這種方式可以指定從分割槽的任意位置開始消費資料，當然這種
//消費者指定要消費的分割槽，指定分割槽之後消費者崩潰之後 不會引發分割槽reblance
consumer.assign(list);
消費資料的方式，如果消費者奔潰之後，不會引發分割槽reblance，也就是說assign的consumer不會擁有kafka的group management機制。

我們上面說過，同一個分片只能由消費者分組中的同一個消費者進行消費，假設當消費者A使用assign指定分割槽進行消費時，如果這時消費者A使用的分組group B，是通過subscribe訂閱了這個主題的分片時，由於消費者A不加入group management，它相當於一個獨立的臨時消費者，這時消費者A也是可以正常消費的，看起來就是一個分片被一個消費者組中的多個消費者消費一樣。

(3)我們還可以配置如下屬性auto.offset.reset來，設定消費者從分割槽的開頭或者末尾進行消費資料。當然這也是有條件的。

 //一般配置earliest 或者latest 值
props.put("auto.offset.reset", "latest");

我把上述三種情況的消費者不同使用方式下，消費者提交offset的情況進行了歸總和說明：


早在kafka0.8.2.2版本的時候，kafka已經支援訊息offset存在brokers中，只不過預設是將offset儲存到zookeeper中。kafka現在最新發布的版本都是預設將資料儲存到brokers中。我的程式碼示例是使用了kafka0.10.0.0版本，當我們這裡通過assign函式分配指定的分割槽時


下面是我的測試程式碼，有興趣的同學可以檢視和驗證上述結論：

/**
 * 
 * @author yujie.wang
 * kafka生產者示例程式碼
 */
public class Producer_Sample {
	//kafka叢集機器
	private static final String KAFKA_HOSTS = "10.4.30.151:9092,10.4.30.151:9093,10.4.30.151:9094";
	//topic名稱
	private static final String TOPIC = "my-replicated-topic_2";
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Producer_Sample producer = new Producer_Sample();
		producer.producer_send(TOPIC);
		System.out.println("end");
	}
	
	/**
	 * 生產者生產資料
	 * 傳送訊息是非同步進行，一旦訊息被儲存到分割槽快取中，send方法就返回
	 * 一旦訊息被接收 就會呼叫callBack
	 * @param topic
	 */
	public void producer_send(String topic){
		Properties props = new Properties();
		//kafka叢集機器
		props.put("bootstrap.servers", KAFKA_HOSTS);
		//生產者傳送的資料需要等待主分片和其副本都儲存才發回確認訊息
		props.put("acks", "all");
		//生產者傳送失敗後的確認訊息
		props.put("retries", 0);
		//生產者 每個分割槽快取大小 16K
		props.put("batch.size", 16384);
		//生產者傳送分割槽快取中資料前停留時間
		props.put("linger.ms", 1);
		//生產者可用快取總量大小 32M
		props.put("buffer.memory", 33554432);
		props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
		 
		Producer<String, String> producer = new KafkaProducer<String,String>(props);
		for(int i = 220; i < 230; i++){
			//傳送訊息是非同步進行，一旦訊息被儲存到分割槽快取中，send方法就返回
		    // producer.send(new ProducerRecord<String, String>("my-replicated-topic_1", Integer.toString(i), Integer.toString(i)));
		    producer.send(new ProducerRecord<String, String>(topic, "call___"+Integer.toString(i+20), "call___"+Integer.toString(i)),
		    		new Call());
		    System.out.println("send return I: "+ i);
		}

		producer.close();
	}

	/**
	 *訊息被儲存之後的回撥方法
	 */
	class Call implements Callback{

		@Override
		public void onCompletion(RecordMetadata recordmetadata,
				Exception exception) {
			// TODO Auto-generated method stub
			System.out.println("callBack: "+ recordmetadata.checksum() + " recordmetadata content : "+recordmetadata.toString());
		}
		
	}
}


/**
 * @author yujie.wang
 * kafka消費者示例，包含隨機位置消費和最多一次消費方式
 * 消費者提交消費資料offset 分為自動提交和手動控制提交
 * 
 * 這份程式碼示例中包含了 多種從kafka的任意位置獲取資料的方式
 */
public class Consumer_Sample {

	//kafka叢集機器
	private static final String KAFKA_HOSTS = "10.4.30.151:9092,10.4.30.151:9093,10.4.30.151:9094";
	//topic名稱
	private static final String TOPIC = "my-replicated-topic_2";
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Consumer_Sample consumer = new Consumer_Sample();
		//從分割槽的末尾 或者已存在groupid的請情況下從未消費位置開始消費資料
		consumer.consumerSubscribe("true", TOPIC);
		// 通過實現ConsumerRebalanceListener介面 進而時間任意位置的消費
		consumer.consumerSubscribeImplListener("true", TOPIC);
		//從指定的分割槽  開始位置seekToBeginning 或者任意位置seek消費資料
		consumer.consumerAssin("true", TOPIC);
		//通過配置屬性auto.offset.reset 來設定消費者從分割槽開頭或者末尾進行消費，但是需要使用一定條件的group Id
		consumer.consumerAutoOffsetReset("true", TOPIC);
		System.out.println("consumer end");
	}
	
	
	/**
	 * 直接通過訂閱一個指定分割槽來消費資料
	 * (1)如果該groupId消費者分組下 有消費者提交過offset,則從 當前提交的offset位置開始消費資料
	 * (2)如果該groupId消費者分組下 沒有有消費者提交過offset,則從 當前log新增的最後位置(也就是資料的末尾)開始消費資料
	 * @param isAutoCommitBool
	 * @param topic
	 */
	public void consumerSubscribe(final String isAutoCommitBool, final String topic){
		 Properties props = new Properties();
		 //配置kafka叢集機器
		 props.put("bootstrap.servers", KAFKA_HOSTS);
		 //消費者分組
		 props.put("group.id", "yujie37");
		 //這裡設定 消費者自動提交已消費訊息的offset
		 props.put("enable.auto.commit", isAutoCommitBool);
		 // 設定自動提交的時間間隔為1000毫秒
		 props.put("auto.commit.interval.ms", "1000");
		 // 設定每次poll的最大資料個數
		 props.put("max.poll.records", 5);
		 props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		 props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		 final KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
		 //訂閱topic
		 consumer.subscribe(Arrays.asList(topic));
		 List<PartitionInfo> parList = consumer.partitionsFor(topic);

		 //打印出分割槽資訊
		 printPartition(parList);

		 //消費資料
		 while (true) {
		     ConsumerRecords<String, String> records = consumer.poll(5000);
		     System.out.println("topic: "+topic + " pool return records size: "+ records.count());
		     for (ConsumerRecord<String, String> record : records){
			 	 System.out.println(record.toString());
			 	  //手動提交已消費資料的offset
			 	 if("false".equalsIgnoreCase(isAutoCommitBool)){
			 		consumer.commitSync();
			 	 }
			 	
		     }
		   
		 }
	}
	
	
	/**
	 * 
	 * @param isAutoCommitBool true 開啟自動提交offset;false 不開啟
	 * @param topic
	 * (1)如果該groupId消費者分組下 有消費者提交過offset,則從 當前提交的offset位置開始消費資料
	 * (2)如果該groupId消費者分組下 沒有有消費者提交過offset,則從 當前log新增的最後位置(也就是資料的末尾)開始消費資料
	 * 
	 * 注意如果enable.auto.commit 設定為false，如果消費完資料沒有提交已消費資料的offset，
	 * 則會出現重複消費資料的情況
	 * 
	 * 通過實現ConsumerRebalanceListener介面中的onPartitionsAssigned方法，並在其中呼叫消費者的seek或者seekToBeginning
	 * 方法定位分割槽的任意位置或者開頭位置
	 */
	public void consumerSubscribeImplListener(final String isAutoCommitBool, final String topic){
		 Properties props = new Properties();
		 //配置kafka叢集機器
		 props.put("bootstrap.servers", KAFKA_HOSTS);
		 //消費者分組
		 props.put("group.id", "yujie26");
		 //這裡設定 消費者自動提交已消費訊息的offset
		 props.put("enable.auto.commit", isAutoCommitBool);
		 // 設定自動提交的時間間隔為1000毫秒
		 props.put("auto.commit.interval.ms", "1000");
		 // 設定每次poll的最大資料個數
		 props.put("max.poll.records", 5);
		 props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		 props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		 final KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
		 //訂閱topic,並實現ConsumerRebalanceListener
		 consumer.subscribe(Arrays.asList(topic), new ConsumerRebalanceListener(){
			@Override
			public void onPartitionsRevoked(//分割槽撤銷時，消費者可以向該分割槽提交自己當前的offset
					Collection<TopicPartition> collection) {
				// TODO Auto-generated method stub
				if("false".equalsIgnoreCase(isAutoCommitBool)){
					//consumer.commitSync();
				}
			}

			@Override
			public void onPartitionsAssigned(//當分割槽分配給消費者時，消費者可以通過該方法重新定位需要消費的資料位置
					Collection<TopicPartition> collection) {
				// TODO Auto-generated method stub
				//將消費者定位到各個分割槽的開始位置進行消費
		/*		consumer.seekToBeginning(collection);
				System.out.println("seek beg");*/
			
				Iterator it = collection.iterator();
				while(it.hasNext()){
					//將消費者定位到指定分割槽的指定位置7進行消費
					consumer.seek((TopicPartition)it.next(), 7);
				}
				
			}
		 });
		 while (true) {
		     ConsumerRecords<String, String> records = consumer.poll(5000);
		     System.out.println("topic: "+topic + "pool return records size: "+ records.count());
		     for (ConsumerRecord<String, String> record : records){
			 	 System.out.println(record.toString());
			 	  //手動提交已消費資料的offset
			 	 if("false".equalsIgnoreCase(isAutoCommitBool)){
			 		consumer.commitSync();
			 	 }
			 	
		     }
		   
		 }
	}
	
	
	/**
	 * 
	 * @param isAutoCommitBool true 開啟自動提交offset;false 不開啟
	 * @param topic
	 * 如果groupId之前存在 ， 則從之前提交的最後消費資料的offset處繼續開始消費資料
	 * 如果groupId之前不存在，則從當前分割槽的最後位置開始消費
	 * 
	 * 注意如果enable.auto.commit 設定為false，如果消費完資料沒有提交已消費資料的offset，
	 * 則會出現重複消費資料的情況
	 */
	public void consumerAutoOffsetReset(final String isAutoCommitBool, final String topic){
		 Properties props = new Properties();
		 //配置kafka叢集機器
		 props.put("bootstrap.servers", KAFKA_HOSTS);
		 //消費者分組
		 props.put("group.id", "yujie32");
		 //這裡設定 消費者自動提交已消費訊息的offset
		 props.put("enable.auto.commit", isAutoCommitBool);
		 // 設定自動提交的時間間隔為1000毫秒
		 props.put("auto.commit.interval.ms", "1000");
		 // 設定每次poll的最大資料個數
		 props.put("max.poll.records", 5);
		 //設定使用最開始的offset偏移量為該group.id的最早。如果不設定，則會是latest即該topic最新一個訊息的offset
	     //如果採用latest，消費者只能得道其啟動後，生產者生產的訊息
		 //一般配置earliest 或者latest 值
	     props.put("auto.offset.reset", "latest");
		 props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		 props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		 final KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
		 //訂閱topic,並實現ConsumerRebalanceListener
		 consumer.subscribe(Arrays.asList(topic));
		 while (true) {
		     ConsumerRecords<String, String> records = consumer.poll(5000);
		     System.out.println("topic: "+topic + "pool return records size: "+ records.count());
		     for (ConsumerRecord<String, String> record : records){
			 	 System.out.println(record.toString());
			 	  //手動提交已消費資料的offset
			 	 if("false".equalsIgnoreCase(isAutoCommitBool)){
			 		consumer.commitSync();
			 	 }
			 	
		     }
		   
		 }
	}

	
	/**
	 * 通過assign分配的分割槽,消費者發生故障 Server端不會觸發分割槽重平衡(即使該消費者共享某個已有的groupId)，每個消費者都是獨立工作的
	 * 為了避免offset提交衝突，需要確保每個消費者都有唯一的groupId
	 * 從指定的分割槽的開頭開始消費資料
	 * @param isAutoCommitBool true 開啟自動提交offset;false 不開啟
	 * @param topic
	 */
	public void consumerAssin(String isAutoCommitBool,String topic){
		 Properties props = new Properties();
		 //配置kafka叢集機器
		 props.put("bootstrap.servers", KAFKA_HOSTS);
		 //消費者分組
		 props.put("group.id", "yujie35");
		 //這裡設定 消費者自動提交已消費訊息的offset
		 props.put("enable.auto.commit", isAutoCommitBool);
		 // 設定自動提交的時間間隔為1000毫秒
		 props.put("auto.commit.interval.ms", "1000");
		 // 設定每次poll的最大資料個數
		 props.put("max.poll.records", 5);
		 props.put("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		 props.put("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
		 KafkaConsumer<String, String> consumer = new KafkaConsumer<>(props);
		 //獲得topic的所有分割槽
		 List<PartitionInfo> parList = consumer.partitionsFor(topic);
		 //打印出分割槽資訊
		 printPartition(parList);
		 
		 List<TopicPartition> list = new ArrayList<TopicPartition>();
		 for(PartitionInfo par : parList){
			 TopicPartition partition = new TopicPartition(topic, par.partition());
			 list.add(partition);
		 }
		 //消費者指定要消費的分割槽，指定分割槽之後消費者崩潰之後 不會引發分割槽reblance
	     consumer.assign(list);

    	 //從list中所有分割槽的開頭開始消費資料，這個操作不改變已提交的消費資料的offset
 	    // consumer.seekToBeginning(list);
	 

	 /*    for(TopicPartition tpar:list ){
	    	 //consumer.seek(tpar, position);
	     } */
     

		 while (true) {
		     ConsumerRecords<String, String> records = consumer.poll(5000);
		     System.out.println("topic: "+topic + " pool return records size: "+ records.count());
		     for (ConsumerRecord<String, String> record : records){
			 	 System.out.println(record.toString());
			 	  //手動提交已消費資料的offset
			 	 if("false".equalsIgnoreCase(isAutoCommitBool)){
			 		consumer.commitSync();
			 	 }
			 	
		     }
		   
		 }
	}
	

	
	

	
	public void printPartition(List<PartitionInfo> parList){
		for(PartitionInfo p : parList){
			System.out.println(p.toString());
		}
	}
	
	/**
	 * 單獨處理每個分割槽中的資料，處理完了之後非同步提交offset,注意提交的offset是程式將要讀取的下一條訊息的offset
	 * @param consumer
	 */
	public void handlerData(KafkaConsumer<String, String> consumer){
		boolean running = true;
		try {
	         while(running) {
	             ConsumerRecords<String, String> records = consumer.poll(Long.MAX_VALUE);
	             for (TopicPartition partition : records.partitions()) {
	                 List<ConsumerRecord<String, String>> partitionRecords = records.records(partition);
	                 for (ConsumerRecord<String, String> record : partitionRecords) {
	                     System.out.println(record.offset() + ": " + record.value());
	                 }
	                 long lastOffset = partitionRecords.get(partitionRecords.size() - 1).offset();
	                 //注意提交的offset是程式將要讀取的下一條訊息的offset
	                 consumer.commitSync(Collections.singletonMap(partition, new OffsetAndMetadata(lastOffset + 1)));
	             }
	         }
	     } finally {
	       consumer.close();
	     }
	}
	
	/**
	 * 關閉消費者
	 * @param consumer
	 */
	public void closeConsumer(KafkaConsumer<String, String> consumer){
		if(consumer != null){
			consumer.close();
		}
	}

}


相關推薦

kafka 從分割槽任意位置、分割槽開頭、分割槽末尾開始消費資料

最近就kafka消費者消費資料時，消費者提交的offset與同事們有一些分歧和討論，這裡記錄一下自己的研究。 我們知道redis和kafka都可以作為訊息佇列使用，都可以完成釋出訂閱功能，但是kafka相較於redis可以實現訂閱訊息的儲存，可以實現訂閱訊息的任意位置消費，

Hive內部表、外部表、分割槽表以及外部分割槽表建立以及匯入資料例項講解

源資料格式： [[email protected]144113 zhang_dd_edw]$ more data.txt 25502#hdfs://ns1/user/dd_edw/adm.db/adm_dealer_order_list_di_big/dt=2015-07-

Hive概述、內部表、外部表、分割槽表的操作

Hive概述、內部表、外部表、分割槽表的操作 一、Hive概述 　　Hive是基於Hadoop的一個數據倉庫工具。可以將結構化的資料檔案對映為一張資料庫表，並提供完整的sql查詢功能，可以將sql語句轉換為MapReduce任務進行執行。 　　Hive是建立在 Hadoop 上的資料倉庫

GPT_MBR與GPT分割槽掃盲，希捷2T、3T硬碟測評（多圖殺貓）。申精！

原地址：http://itbbs.pconline.com.cn/diy/15657192.html 前言——         運氣不好，兩隻1T硬碟先後出現異常（2010年最先降到￥399的日立HDS721010CLA

Spark任務中如何確定spark分割槽數、task數目、core數、worker節點個數、excutor數量

先上圖： 每一個過程的任務數，對應一個inputSplit1, Partition 輸入可能以多個檔案的形式儲存在HDFS上，每個File都包含了很多塊，稱為Block。 當Spark讀取這些檔案作為輸入時，會根據具體資料格式對應的InputFormat進行解析

mysql建立分割槽、儲存統計、定時事件

DROP TABLE IF EXISTS monitor_printer; CREATE TABLE monitor_printer ( id int NOT NULL AUTO_INCREMENT COMMENT '自增長id（主鍵）', monitorId int NOT NULL C

ORACLE分割槽表梳理系列（一）- 分割槽表概述、分類、使用方法及注意事項

前言 本文著重闡述分割槽表的概念、優勢，以及常用分割槽表的使用方法及使用過程中的注意事項。 對於分割槽表的日常維護方法，如：索引的維護、分割槽的合併等，將在後續文章中再詳細介紹。 本文涉及的相應演示，使用的資料庫版本為oracle 11.2.0.4。 本文常用分割槽表的使

2-5、Linux中GPT分割槽

1、磁碟分割槽與格式化 分割槽模式之MBR 主分割槽不超過4個 單個分割槽容量最大2TB 分割槽模式之GPT 主分割槽個數“幾乎”沒有限制 單個分割槽容量“幾乎”沒有限制 GPT的主分割槽中，不適合安裝x86架構的系統（32位作業系統） 2、GPT的分割槽 命令

一起學Hive——建立內部表、外部表、分割槽表和分桶表及匯入資料

Hive本身並不儲存資料，而是將資料儲存在Hadoop的HDFS中，表名對應HDFS中的目錄/檔案。根據資料的不同儲存方式，將Hive表分為外部表、內部表、分割槽表和分桶表四種資料模型。每種資料模型各有優缺點。通過create user命令建立user表時，會在HDFS中生成一個user目錄/檔案。 外部表

第五週作業 磁碟分割槽、shell指令碼、lvm邏輯卷

一、什麼是GPT,有什作用？ inux中磁碟分割槽分為MBR和GPT。一一MBR全稱為Master Boot Record，為主引導記錄，是傳統的分割槽機制，應用於絕大多數使用的BIOS的PC裝置。 MBR分割槽主分割槽數目不能超過4個 MBR分割槽方案無法支援超過2TB容量的磁碟。因為這一方案

再linux系統中對磁碟進行gpt分割槽、建立swap交換分割槽、磁碟加密和磁碟配額

     摘要：本文主要介紹四個實驗：一是如何修改磁碟的分割槽方式為gpt方式，二是劃分swap交換分割槽，三是給磁碟加密，四是設定磁碟配額。 一、修改磁碟為gpt的分割槽方式 ##1.先用   fdisk -l  檢視分割槽狀態，若已經存在分割槽，那我們就直接修改已經存

Ubuntu分割槽方案（菜鳥方案、常用方案和進階方案）

轉自https://blog.csdn.net/Alvern_Zhang/article/details/48392895 菜鳥方案 “/”與swap兩個分割槽就可以應付絕大多數的應用 常用方案 分為3個區  1. 掛載點/；主分割槽；安裝系統和軟體；大小為30G；分割槽格式為ex

Hadoop詳解 ----------- shuffle原理、partitioner分割槽原理、Combiner程式設計、常見的MR演算法

Partitioner程式設計Partition簡介shuffle是通過分割槽partitioner 分配給Reduce的 一個Reducer對應一個記錄檔案Partitioner是shuffle的一部

Mysql關於分庫、分表、分割槽的具體介紹

1、分表 分表是將一個大表按照一定的規則分解成多張具有獨立儲存空間的實體表，我們可以稱為子表，每個表都對應三個檔案，MYD資料檔案，.MYI索引檔案，.frm表結構檔案。這些子表可以分佈在同一塊磁碟上，也可以在不同的機器上。app讀寫的時候根據事先定義好的規則得到對應的子表

C++ BSS段、資料段、程式碼段、堆與棧及五大記憶體分割槽

BSS段：BSS段（bss segment）通常是指用來存放程式中未初始化的全域性變數的一塊記憶體區域。BSS是英文Block Started by Symbol的簡稱。BSS段屬於靜態記憶體分配。 資料段：資料段（data segment）通常是指用來存放程式中已

Linux系統，磁碟、分割槽、檔案系統、格式化、掛載的理解。

1. 背景知識        學習Linux系統應該忘記Windows系統中劃分碟符（C：\。d：\。E：\ ...）的影響。        在Linux的系統中，是通過分割槽來把系統空間劃分成不同的應

作業系統記憶體管理——分割槽、頁式、段式管理

計算儲存的層次結構： 當前技術沒有能夠提供這樣的儲存器，因此大部分的計算機都有一個儲存器層次結構，即少量的非常快速、昂貴、易變的快取記憶體(cache)；若干兆位元組的中等速度、中等價格、易變的主

解決sqoop從mysql匯入到hive表的多分割槽問題

參考：http://blog.csdn.net/liweiwei71/article/details/23434189 對於分割槽表 drop table track_log; create table track_log ( id                    

Hive內部表、外部表、分割槽表介紹

1.內部表： hive>create table tt (name string , age string); //此時會在hdfs的/user/hive/warehouse/目錄下新建一個tt表的資料存放地 hive>load data inpath '/input/data' into tab

Linux 檢視磁碟分割槽、檔案系統、使用情況的命令和相關工具介紹

提要：Linux 磁碟分割槽表、檔案系統的檢視、統計的工具很多，有些工具是多功能的，不僅僅是檢視磁碟的分割槽表，而且也能進行磁碟分割槽的操作；但在本文，我們只講磁碟分割槽的檢視，以及分割槽的使用情況的檢視；本文只是給新手上路之用；關於分割槽工具的操作，我將在以後做專門介紹；此文目的:主要是向初學者介紹一下入