1) The default is to process the whole operation in a single batch. So if, for example, you give a DataTable with 10000 rows to SqlBulkcopy for inserting it into the DB, then BulkInsert will insert the whole 10000 rows in a single batch. By adjusting the batch size property you can tell it to send several smaller batches. You will need to do a bit of benchmarking to find out the optimal value because it depends on your data size and on the characteristics of the server and network. A batch size of 4000 is typical, but your results may vary.
2) Yes, the transactions work with the bulk inserts, so if you roll back the transaction, any inserts as well as anything else that you did within the transaction will be rolled back. EDIT: But you need to use an explicit transaction for this to work. There is a property called UseInternalTransaction, but this only works for each individual batch. Other batches will not be rolled back if an insert fails, unless you started an explicit transaction before starting the bulk copy.
Be aware, however, that bulk inserts have some differences in behavior when compared to standard insert statements. For instance, if the database recovery model is set to bulk logged, then then the bulk inserts are not logged individually; triggers are not fired; block allocation in tables uses larger blocks (which could affect database growth if you are using bulk insert for smallish amounts of data), and so on. On the other hand, they are significantly faster than individual inserts, if you really need the speed.
3) Table locking is affected by the number of rows inserted in the table. Initially, row locking is used, but then the server escalates it to page locks and then table locks as needed for efficiency. This happens regardless of whether you are using bulk insert or individual insert statements.
Note that, depending on the version of SQL Server, if the table has indexes then inserting data from multiple threads will have horrible performance due to the locking on the indexes. This has been greatly alleviated in SQL Server 2019, but it can hurt performance if you try to insert lots of rows from multiple threads in an earlier version.